Getting our machines set up for C++ development, and introducing the fundamental building blocks of programming - variables.

Getting our computer set up so we can create and build C++ programs. Then, creating our very first application

Setting up a C++ Development Environment

An introduction to the building blocks of our software - objects, and the variables that can be associated with them.

Objects, Variables and Types

Creating variables to store and update the data that describes our objects.  We also introduce comments, allowing us to describe our code in plain language.

Creating Variables

An introduction to the different types of numbers in C++, and how we can do basic math operations on them.

Numbers

An overview of the fundamental true or false data type, how we can create them, and how we can combine them.

Booleans - `true` and `false` values

Explore how C++ programs store and manage numbers in computer memory, including integer and floating-point types, memory allocation, and overflow handling.

Types and Literals

Creating a tiny program using numbers and booleans, then adding some breakpoints so we can step through our code in a debugger.

Introduction to Debugging

Types and Variables

Discover how we can package our code into reusable functions that we can easily call.  Then, learn how we can use conditionals and loops to control the flow of our program.

An introduction to functions - reusable blocks of code that we can use to break our application into smaller pieces.

Creating and Calling Functions

An introduction to how our function calls create a call stack, and how we can navigate it in a debugger.

The Call Stack and Debugging Functions

Use booleans and if statements to make our functions and programs more dynamic, choosing different execution paths.

Conditional Logic

Learn an alternative way to write conditionals, which is often used when we want to take different paths based on a specific value

Switch Statements

Allow our functions to communicate with their caller by returning values when they complete

Function `return` Statements

Going into more depth on what is happening when a variable is used as a different type

Implicit Conversions and Narrowing Casts

Making our functions more useful and dynamic by providing them with additional values to use in their execution

Function Arguments and Parameters

Learn more about how and when we can access variables, by understanding the importance of the scope in which they exist.

Scope

Understand what function prototypes are, and learn how we can use them to let us order our code any way we want.

Forward Declarations

Learn how we can use loops to iterate over a block of code, executing it as many times as needed.

Loops

Learn how we can use the modulus operator to get the remainder of integer division, and some common use cases.

The Modulus Operator (`%`)

Put everything we've learned in this chapter to the test by creating a C++ version of the Fizz Buzz game.

Fizz Buzz

Learn how the `&&` and `||` operators are optimized with short-circuit evaluation, only evaluating expressions when necessary

Short-circuit Evaluation

Functions, Conditionals and Loops

Classes and structs are the fundamental feature of object oriented programming.  In this chapter, we will see how we can set them up, and how we can use them to create the custom types our program needs.

Learn how to define, instantiate, and utilize classes, understanding how they form the backbone of object-oriented programming.

Abstraction and Classes

A guide to encapsulation, class invariants, and controlling data access with `public` and `private` specifiers.

Encapsulation and Access Specifiers

Learn about special functions we can add to our classes, control how our objects get created and destroyed.

Constructors and Destructors

Discover the role of structs, how they differ from classes, and how to initialize them without requiring a constructor.

Structs and Aggregate Initialization

This lesson introduces operator overloading, a fundamental concept to create more intuitive and readable code by customizing operators for user-defined types

Operator Overloading

This lesson introduces Structured Binding, a handy tool for unpacking simple data structures

Structured Binding

Classes and Structs

See how we can use inheritance to organise our classes into a hierarchy, unlocking a massive range of possibilities for building more complex software

In this lesson, we explore C++ inheritance, guiding you through creating and managing class hierarchies to streamline your code

Inheritance

Learn about `protected` class members in C++, including how and when to use them in your code, especially in the context of inheritance and class design

Protected Class Members

This lesson introduces Member Initializer Lists, focusing on their advantages for performance and readability, and how to use them effectively

Member Initializer Lists

This lesson provides an in-depth exploration of using inherited methods and variables in C++, covering constructor calls, variable modification, and function shadowing

Working with Inherited Members

An introduction to working with memory, and how we represent memory locations using references and pointers

This lesson introduces references, explaining how they work, their benefits, and their role in performance and data manipulation

References

This lesson provides a thorough introduction to pointers in C++, covering their definition, usage, and the distinction between pointers and references

Pointers

Learn about the `this` pointer in C++ programming, focusing on its application in identifying callers, chaining functions, and overloading operators.

The `this` Pointer

Learn about an important consideration when returning pointers and references from functions

Dangling Pointers and References

Memory, References and Pointers

An introduction to polymorphism - the key tool that let us build more complex programs whilst keeping our code simple.

This lesson provides an in-depth look at function overloading in C++, covering its importance, implementation, and best practices

Function Overloading

Explore the concept of static casting in C++, including examples and best practices for converting data types at compile time

Static Casting

This lesson provides an introduction to virtual functions and overrides, focusing on their role in enabling runtime polymorphism

Virtual Functions and Overrides

Get to grips with downcasting in C++, including static and dynamic casts. This lesson provides clear explanations and practical examples for beginners

Downcasting

Polymorphism

Go deeper on what is happening when we build our software.  Learn how we can use the preprocessor to automatically modify our source code before it is compiled, and how the linker connects our program together.

Explore the essential concepts of C++ preprocessing, from understanding directives to implementing macros

Preprocessor Definitions

Discover how the `#include` directive helps us include library features and split our project across multiple files.

The `#include` Directive

Explore how header files and linkers streamline C++ programming, learning to organize and link our code effectively

Header Files

The Preprocessor and the Linker

Discover additional methods and techniques to keep our data and code organised.

Learn the essentials of using namespaces to organize your code and handle large projects with ease

Namespaces

Learn about Enums and how they offer an efficient way to handle predefined values in your code

Enums

This lesson introduces the `using` keyword in C++, focusing on namespaces, enums, and type aliasing

The `using` Keyword

Namespaces and Enums

Learn how to store collections of objects, and take control of how memory is managed

Explore the fundamentals of dynamic arrays with an introduction to `std::vector`

Dynamic Arrays using `std::vector`

Learn how to manage dynamic memory using unique pointers and the concept of memory ownership

Memory Ownership and Smart Pointers

Explore advanced techniques for managing object copying and resource allocation

Copy Constructors and Operators

Learn the techniques and pitfalls of manual memory management in C++

Managing Memory Manually

Arrays and Dynamic Memory

Techniques to simplify our code, making it easier to understand and maintain

This lesson covers how we can ask the compiler to infer what types we are using through the `auto` keyword

Automatic Type Deduction using `auto`

Learn the intricacies of using `const` and how to apply it in different contexts

Constants and `const`-Correctness

This lesson provides an overview of effective commenting strategies, including Javadoc style commenting for automated documentation

Effective Comments and Javadoc

This lesson introduces the concept of Style Guides and ClangFormat, focusing on how to achieve consistency in our code

Style Guides and Automatic Code Formatting

An introduction to static analysis tools, and how they can help beginners learn faster and improve code quality

Static Analysis

Explore the fundamentals of attributes, including `[[nodiscard]]`, `[[likely]]`, and `[[deprecated]]`

Attributes

Clean Code

A collection of lessons covering a variety of topics worth learning as a beginner

This lesson covers the basics of using randomness, with practical applications

Random Number Generation

Learn the basics of the chrono library and discover how to effectively manage durations, clocks, and time points

Dates, Times and Durations

A detailed guide to string formatting using C++20's `std::format()`, and C++23's `std::print()`

String Interpolation

Learn how to overload the `<<` operator, so our custom types can stream information directly to the console using `std::cout`

Overloading the `<<` Operator

This lesson introduces system calls, and how to use them to clear the terminal

System Calls and Terminal Management

This lesson introduces the fundamentals of capturing user input, using `std::cin` and `std::getline()`

User Input in the Terminal

Unravel the fundamentals of bitwise operators and bit flags in this practical lesson

Bitwise Operators and Bit Flags

Odds and Ends

This course is designed for beginners. We'll take you from the fundamentals and lay a solid foundation for creating real-world programs and learning more advanced concepts.

Become a software engineer with C++.  Starting from the basics, we guide you step by step along the way

This course teaches the fundamentals of C++ while instilling habits used by real-world developers. You'll gain practical experience with concepts that are the foundation of all modern programming.

No previous programming experience is needed - we start from the basics.

Start your Journey

We explain every line of code we're using, so you understand exactly what is happening.

Understand Every Line of Code

Everything we create is organised and implemented using modern, professional practices.

Use Professional Best Practices

We don't just explain what we're doing, but also why. This builds transferrable skills, so you can take what you've learnt and apply them to your own projects.

Focus on Transferrable Skills

No paywalls, no ads - the course is completely free with unlimited access

Free and Unrestricted Access

We break complex concepts into manageable steps, making even advanced topics feel approachable.

Step-by-Step Learning

What You'll Learn

Comprehensive course covering advanced concepts, and how to use them on large-scale projects.

Professional C++

If you're already familiar with the basics of C++ and object oriented programming, you may want to skip to the advanced course.  It starts with a quick summary of everything we cover here.

Already Familiar with Programming?

Intro to C++ Programming

In C++, we use quotes to help the compiler understand exactly what we mean. When we write a number like `42`, the compiler knows this is a numeric value that can be used in calculations.


But when we write text, we need a way to tell the compiler "this is just text - don't try to interpret it as anything else".  Let's look at an example:


```c++
#include <iostream>
using namespace std;

int main() {
  // number - no quotes needed
  cout << 42 << "\n";

  // text - needs quotes
  cout << "42" << "\n";

  // math expression - calculates to 42
  cout << 15 + 27 << "\n";

  // text - just prints exactly what we wrote
  cout << "15 + 27" << "\n";
}
```


```plain text
//<o>
42
42
42
15 + 27
```


Without quotes, the compiler treats things differently:

- `42` is a number we can do math with
- `"42"` is just text that happens to contain digits
- `15 + 27` gets calculated to give us `42`
- `"15 + 27"` is treated as literal text to display

This becomes really important when we start doing calculations. For example:


```c++
#include <iostream>
using namespace std;

int main() {
  // works fine - does the math
  cout << 42 + 8 << "\n";

  // this will cause some weird output!
  cout << "42" + 8 << "\n"; //<w>
}
```


```plain text
//<o>
50

```


The quotes tell C++ "this is text" (technically called a string literal), while no quotes means "this is a value we can do math with". This distinction becomes even more important as we learn about variables and different types of data in future lessons.

Why Text Needs Quotes

This is a common issue when running C++ programs, especially on Windows. When we run our program, it executes all our instructions very quickly, then immediately exits - often before we can see the output!


There are several ways to handle this. Let's look at the most common approaches:


## Using System Commands


One way is to use system-specific commands to pause the program:


```c++
#include <iostream>
using namespace std;

int main() {
  cout << "Hello World!\n";

  // works on Windows but not recommended
  system("pause"); //<w>
}
```


```c++
//<o>
Hello World!
Press any key to continue . . .
```


However, this approach isn't recommended because:

- It's system-dependent (won't work on Mac/Linux)
- It can be a security risk
- It's not a "clean" C++ solution

## Reading Input


A better approach is to wait for user input:


```c++
#include <iostream>
using namespace std;

int main() {
  cout << "Hello World!\n";
  cout << "Press Enter to continue...";
  cin.get(); // waits for Enter key //<h>
}
```


```c++
//<o>
Hello World!
Press Enter to continue...
```


## Running from Command Line


The best solution is to run your program from a command prompt/terminal. The window will stay open until you close it:

1. Open Command Prompt (Windows) or Terminal (Mac/Linux)
2. Navigate to your program's folder
3. Run your program from there

For example, if your program is called "hello.exe":


```plain text
//<ti>
cd C:\MyPrograms
hello.exe
```


## IDE Solutions


Most IDEs provide ways to keep the console window open:

- Visual Studio: Run with Ctrl+F5 instead of F5
- VS Code: Add a launch configuration
- Other IDEs often have similar options in their settings

As you progress in programming, you'll want to get comfortable with running programs from the command line - it's a valuable skill that gives you more control over how your programs run and how you can interact with them.

Program Closes Too Fast

When you forget a semicolon in C++, the compiler will generate an error because it can't figure out where one statement ends and the next begins. The error messages can sometimes be confusing though!


Let's look at an example:


```c++
#include <iostream>
using namespace std;

int main() {
  // missing semicolon!
  cout << "First line\n"  //<e> 
  cout << "Second line\n";
}
```


```plain text
//<oe>
error: expected ';' before 'cout'
```


The compiler tries to help by pointing to where it got confused, but sometimes the error appears on the line _after_ the missing semicolon. This is because C++ doesn't know a statement is supposed to end until it hits either a semicolon or something that can't possibly be part of the current statement.


To make your code easier to debug:

- Add semicolons as you write each line, don't wait until the end
- When you get errors, always check the line _before_ the error for a missing semicolon
- Use proper indentation to make statement boundaries clearer
- Most modern IDEs will highlight missing semicolons as you type

Remember: In C++, semicolons are statement terminators, not line terminators. This means you can actually write multiple statements on one line (though it's not recommended for readability):


```c++
#include <iostream>
using namespace std;

int main() {
  cout << "One"; cout << "Two"; cout << "Three";  //<w>
}
```


```plain text
//<o>
OneTwoThree
```

Forgetting Semicolons

You'll often see two different styles for using things from the C++ standard library:


## Style 1: `using namespace`


In our introductory lessons, we add a `using namespace std;` statement near the top of our files:


```c++
#include <iostream>
using namespace std;  //<h>

int main() {
  cout << "Hello\n";     // no std:: needed
  string name{"World"};  // no std:: needed
}
```


## Style 2: Explicit `std::`


We can remove this, and instead use the `std::` prefix any time we want to use a capability from the C++ standard library:


```c++
#include <iostream>

int main() {
  // explicitly showing these come from std
  std::cout << "Hello\n"; //<h> 
  std::string name{"World"};  //<h>
}
```


Both styles work perfectly fine, but there are good reasons why many developers prefer using `std::`.


## Benefits of Using `std::`


Code Clarity:

- It's immediately clear where things come from
- Helps when reading unfamiliar code
- Makes it easier to spot what features you're using

Avoiding Naming Conflicts:


```c++
#include <string>

namespace game {//<h>
class string {};  // our own string class//<h>
}//<h>

int main() {
  // clearly using std::string
  std::string text{"Hello"};

  // clearly using our string
  game::string gameText{};
}
```


Professional Practice:

- Many companies require this style in their coding standards
- It's common in open source projects
- Makes code more maintainable in large projects

Remember: For this course, either style is fine - just be consistent within each program. As you progress to larger projects, you'll develop a preference based on your needs and team standards.

Understanding `std::` Prefix

The line `using namespace std;` is a convenience feature that lets us use things from the standard library without typing `std::` before them. Let's see what happens when we remove it:


```c++
#include <iostream>
using namespace std; //<d>

int main() {
  // won't compile without std::
  cout << "Hello World!\n";  //<e>
}
```


```plain text
//<oe>
error: 'cout' was not declared in this scope
```


To fix this, we need to specify that we're using `cout` from the `std` namespace:


```c++
#include <iostream>

int main() {
  //  works fine with std:: prefix
  std::cout << "Hello World!";  //<h>
}
```


```c++
//<o>
Hello World!
```


## Why Namespaces Exist


Namespaces help prevent naming conflicts. Imagine two different libraries both have a function called `print()`:


```c++
#include <iostream>

namespace printerLib {
void print() {
  std::cout << "Printing document...\n";
}
}

namespace graphicsLib {
void print() {
  std::cout << "Drawing to screen...\n";
}
}

int main() {
  // we know exactly which print() to use
  printerLib::print();

  // no confusion about which one we mean
  graphicsLib::print();
}
```


```plain text
//<o>
Printing document...
Drawing to screen...
```


## Why Some People Avoid `using namespace std`


While `using namespace std;` is fine for learning and small programs, many developers prefer to explicitly write `std::` because:

- It makes it clear where things come from
- It prevents potential naming conflicts in larger programs
- It's considered more professional style

You can also be selective about what you import:


```c++
#include <iostream>

using std::cout;  // only import cout //<h>

int main() {
  // cout works without std::
  cout << "Hello World!";

  // endl still needs std::
  cout << std::endl;
}
```


For this course, using `using namespace std;` is perfectly fine - just be aware that you'll see both styles in real-world code.

Understanding namespace std

Writing code that works across different operating systems (cross-platform code) is an important skill. Here are the key things to consider:


## File Paths


Different systems use different path separators:


```c++
#include <fstream>
#include <iostream>

int main() {
  //  Windows style
  std::ifstream file("data\\config.txt"); //<w>

  // Works everywhere
  std::ifstream file2("data/config.txt"); //<h>
}
```


## Line Endings


Different systems handle line endings differently, but `\n` works everywhere:


```c++
#include <iostream>
using namespace std;

int main() {
  cout << "Line 1\n";   // Works everywhere //<h>
  cout << "Line 2\r\n"; // Windows-specific //<w>
}
```


## System Commands


Avoid system-specific commands:


```c++
#include <iostream>

int main() {
  //  Windows only - clears screen
  system("cls");    //<w>

  //  Unix only - clears screen
  system("clear");  //<w>

  // Instead, use portable solutions:
  std::cout << "Press Enter to continue...";
  std::cin.get();  // Works everywhere //<h>
}
```


## Best Practices for Cross-Platform Code


Use Standard C++ Features:


```c++
#include <iostream>
#include <string>

int main() {
  std::string name;
  std::cout << "Enter name: ";

  // Works everywhere
  std::getline(std::cin, name); //<h>
}
```


Avoid Platform-Specific Headers:


```c++
// Standard C++ - works everywhere
#include <iostream> //<h>

// Windows-specific - avoid unless necessary
#include <windows.h> //<w>
```


Use Cross-Platform Libraries:

- Standard Library (`std::`) features work everywhere
- Popular cross-platform libraries like SDL, SFML, or Qt can help
- Avoid OS-specific APIs unless absolutely necessary

When Platform-Specific Code is Needed:


```c++
#include <iostream>

int main() {
#ifdef _WIN32
  // Windows-specific code here
#elif __APPLE__
  // Mac-specific code here
#elif __linux__
  // Linux-specific code here
#else
  // Default code here
#endif
  std::cout << "This code runs everywhere!\n";
}
```


Remember: The C++ Standard Library is your friend for cross-platform development. Stick to standard features when possible, and your code will work across different systems without modification.


When you do need platform-specific features, use conditional compilation to handle the differences cleanly.

Cross-Platform Code

File extensions tell both the computer and the programmer what kind of file we're working with. For C++ programs, we typically use `.cpp`, but there are several related extensions you might encounter:


## Common C++ Extensions

- `.cpp` - Main C++ source files (most common)
- `.cc` - Alternative C++ source extension (common in Linux)
- `.h` or `.hpp` - Header files (we'll learn about these later)
- `.c` - C language source files (C++ is based on C)

The main difference is how your computer and IDE treat these files:


```c++
// main.cpp - will be compiled as C++
#include <iostream>
using namespace std;

int main() {
  cout << "This is a C++ program!";
}
```


If we saved the exact same code as `main.txt`:

- The IDE won't syntax highlight it properly
- The compiler won't recognize it as code
- We can't build and run it directly

## Why Extensions Matter


The extension tells your development tools:

- Which syntax highlighting to use
- Whether the file should be compiled
- Which compiler settings to use
- Which language rules to enforce

For example, saving a C++ file as `.c` might cause issues:


```c++
// main.c - compiler will treat this as C code

// C doesn't have iostream!
#include <iostream>  //<e>

int main() {
  // cout doesn't exist in C
  std::cout << "This won't compile as C!";  //<e>
}
```


## Different Extensions for Different Tools


Some IDEs create additional files with their own extensions:

- `.sln` - Visual Studio solution files
- `.vcxproj` - Visual Studio project files
- `.o` or `.obj` - Compiled object files
- `.exe` - Windows executable (the final program)

For now, just remember to save your C++ code files with the `.cpp` extension - this ensures your development environment will treat them properly as C++ source code.

C++ File Extensions

Compiling and running are two distinct steps in getting your program to work. Let's break this down:


## Compiling


Compiling is like translating your C++ code into a language your computer understands:


```c++
// Your C++ code (human-readable)
#include <iostream>
using namespace std;

int main() {
  cout << "Hello World!";
}
```


The compiler converts this into machine code (not human-readable):


```plain text
01001000 01100101 01101100 01101100 ...
```


## Running


Running means actually executing the compiled program. Your computer:

1. Loads the machine code into memory
2. Follows the instructions
3. Produces the output

## The Complete Process

1. Writing (You create `.cpp` files)
2. Compiling (Compiler creates `.exe` or similar)
3. Running (Computer executes the program)

Here's what can happen at each stage:


### Compile-Time Errors


The following program is not valid C++.  We forgot to include the semicolon, so the compiler cannot understand the code we wrote:


```c++
#include <iostream>
using namespace std;

int main() {
  // won't compile!
  cout << "Forgot semicolon"//<e>
}
```


```c++
//<oe>
error C2143: syntax error: missing ';' before '}'
```


### Run-Time Errors


The following program has valid code so will compile successfully.  However, the code includes an instruction to divide by zero, which will cause an error once we run the program:


```c++
#include <iostream>
using namespace std;

int main() {
  // compiles but crashes when run!
  cout << 100 / 0;//<w>
}
```


### Successful Program


The following program will both compile and run successfully:


```c++
#include <iostream>
using namespace std;

int main() {
  // compiles and runs fine
  cout << "This works!"; //<h>
}
```


```plain text
//<o>
This works!
```


Think of it like baking:

- Writing code is like writing a recipe
- Compiling is like gathering and preparing ingredients
- Running is like actually cooking the dish

You must successfully compile before you can run - just like you need ingredients before you can cook!

Compiling vs Running

<Excerpt>


In this introductory lesson, we'll create our first program in C++!  We will start very simply.  We'll just be outputting some text to the screen.


Things will ramp up quickly, but first, our priority is to make sure we have everything we need to start writing and running C++ programs.


If you do not have a development environment set up yet, let's start by going through some options we have.


</Excerpt>


## Selecting a Code Editor


If you do not yet have a code editor, now is the time to get one! There are plenty of free options for every major operating system:

- For Windows, [Visual Studio](https://visualstudio.microsoft.com/vs/community/) is the common choice.  Note that Visual Studio and Visual Studio Code are different editors - Visual Studio is what we want for C++.  The Community Edition is free and has everything we'll need.
- For Mac, [CLion](https://www.jetbrains.com/clion/#) or [Xcode](https://developer.apple.com/xcode/) are recommended.
- For Linux, [CLion](https://www.jetbrains.com/clion/#) or [Qt Creator](https://www.qt.io/product/development-tools) are common choices.

Note that CLion is only free for education and non-commercial use.  If you want to use it for other purposes, you will need to pay for a license.


The screenshots we show in this course will be from Visual Studio, but it's not that important what software you use. The interface and processes will be very similar, and the code will be entirely identical.


<Ad />


When installing your editor, ensure that you include C++ components during the setup if given the option.  This can be done by reviewing the online documentation for your editor.


This course requires nothing special or unusual - the basic ability to create modern C++ programs will fulfill our needs.


In Visual Studio, this can be done by selecting one of the C++ _**Workloads**_ during installation - for example, _**Desktop Development with C++**_ or _**Game Development with C++**_


<Img file="vs-install-components.png" width="1546" height="1087" alt="A screenshot of the visual studio installer" blurHash="L1SPX{R+4nV@?b_3E1Ip9E9FWYt7" />


If you already have Visual Studio installed without these components, you can configure your installation simply by running the installer again.


<Definition>


### Integrated Development Environments (IDEs)


In the past, developers relied on multiple separate tools throughout their workflow.


That's still an option but, today, most developers use an **Integrated Development Environment**.  An IDE is a single program that brings together the essential tools in one place.


With an IDE, you can write your code, convert it into an executable program, and run it, all without switching between different applications.


Using an IDE is especially helpful for beginners, as it simplifies the development process.  All of the tools previously recommended fall under the category of IDEs.


</Definition>


## Hello World


Once we've got your editor of choice set up, create a new, blank C++ project with it.


In Visual Studio, this involves creating an _Empty Project_ from the _Create a new project_ window.  This window should be accessible from your start screen, or _File > New > Project_ from the top menu bar.


<Img file="vs-setup-1.PNG" width="1263" height="836" alt="A screenshot of the visual studio window used to create a new project" blurHash="L05E$[oZ4U-:_2?coaa%a*-.?cIT" />


Once we create the project, we can then add our first C++ file to it.


Other editors may have automatically included a starting file when they generated the project, in which case this step can be skipped.


In Visual Studio, we can add a file from the top menu bar under _Project > Add New Item_.


We can call our file anything we want - I've gone with `main.cpp`


<Img file="vs-add-new-item.PNG" width="1175" height="817" alt="A screenshot of the Visual Studio window for creating a new file" blurHash="LF8z.Gj[ofay~qfRaxay~qayWBay" />


In Visual Studio, this will create a new, empty file in our project.


If you're using a different editor, and that editor included a starting file for you, they may also have included some code in that file.  If so, delete their starting code.


We want to have our starting code look exactly like what is below:


```c++
#include <iostream>
using namespace std;

int main() {
  cout << "Hello World!";
}
```


To ensure everything works, paste this code into your `main.cpp`, save your file then build and run the program.


In most IDEs, this can be done by pressing a button somewhere in the user interface.  In Visual Studio, for example, we can use the _Start Without Debugging_ button on the top menu.


<Img file="vs-start.PNG" width="859" height="310" alt="A photo of the Visual Studio interface" blurHash="L15hV=u4?GK4~XJB-BpInNNGi_kq" />


Our program should open a terminal where we see the output of the code - a simple "Hello World!" message.


```c++
//<o>
Hello World!
```


<Error>


### Extended Character is not Valid in an Identifier


C++, and programming languages in general, are very strict about the symbols used in our code.


One of the most common reasons the simple previous example won't work is that we've used the wrong form of quotation marks when entering `"Hello World"`.


There are several different options we have.  We must be specifically using the `"` character, commonly called "straight double quotes".  On most keyboards, this is either near the right-shift key or above the `2` on the top row.


Other options, such as ", ' and ` may look similar, but they are not equivalent, and won't work.


</Error>


<Definition>


### Compilers and Compiling


Converting our code into a program that can be executed on a computer is usually referred to as _**compiling**_ or _**building**_ the program.  The software that converts our code to an executable program is called a _**compiler**_.


When we install a C++ IDE like Visual Studio, a compiler is typically bundled into the package we downloaded.  Microsoft's C++ compiler is called _**MSVC**_ (Microsoft Visual C++).


MSVC, and most C++ compilers, can be used as standalone programs - we can write code in any text editor and use a compiler to convert it to a program.  IDEs like Visual Studio combine text editing and compilation into a single user interface to give us a more seamless experience.


</Definition>


## Understanding our Program


By the end of this course, you'll understand what every line of code is doing, but for now, we need to skip over some things.


Until we introduce those more advanced topics, our code files should always follow the basic structure of the previous example.


Initially, we will limit our changes to just the area between the `{` and `}`


Currently, that line of code is `cout << "Hello World!";`.


`cout` is an abbreviation of "character output".  When we write (or "stream") things to the character output, it should appear in a terminal or console window when we run our program.


We stream things to the character output using the `<<` operator, with `cout` on the left and the thing we want to stream on the right.


<Definition>


### Operators


An operator is a symbol that performs some action on one or more objects in our program.  `<<` is an example of an operator.


In the `cout << "Hello World!"` example, the objects it is acting upon are `cout` and `"Hello World"`


The objects an operator acts upon are sometimes called its _**operands**_.  We'll see many more examples of operators, and get very comfortable with them over the following lessons.


</Definition>


If the thing we want to stream is some text, we need to put the text in double quotes, such as `"Hello World!"` or `"Goodbye!"`.


Finally, we need to end our statement using a semi-colon `;`


<Definition>


### Statements


In programming, a **statement** is an instruction - some action we are commanding the computer to carry out.


In C++, and many other programming languages, a semicolon `;` is used to denote the end of each statement.


</Definition>


We can stream as many things to the output as we want simply by repeating the pattern on additional lines:


```c++
#include <iostream>
using namespace std;

int main() {
  cout << "Hello World!";
  cout << "My Name is Ryan";
  cout << "Goodbye";
}
```


```json
//<o>
Hello World!My Name is RyanGoodbye
```


## Line Breaks


Even though our previous code was spanned across multiple lines, we can see that our output wasn't.  As we'll see later in this chapter, C++ is fairly flexible about the spacing around our code.  There are many ways to lay out the code in any given file, and our layout choice generally won't affect how our program behaves.


However, it would be nice if we could add some spacing that does affect the _**output**_ of our program. To insert a line break into our output, we stream the special sequence `"\n"`.  Note the direction of the slash is important - we need `\`, not `/`


Any subsequent output will then be on a new line:


```c++
#include <iostream>
using namespace std;

int main() {
  cout << "Hello World!";
  cout << "\n";//<h>
  cout << "My Name is Ryan";
  cout << "\n";//<h>
  cout << "Goodbye";
}
```


```c++
//<o>
Hello World!
My Name is Ryan
Goodbye
```


We don't need to stream `\n` as a standalone statement - we can include it as part of the text we're streaming as part of an existing statement.  We can even place an `\n` within the middle of a string of text.


So, we could have written our previous program like this:


```c++
#include <iostream>
using namespace std;

int main() {
  cout << "Hello World!\n";
  cout << "My Name is Ryan\nGoodbye";
}
```


```c++
//<o>
Hello World!
My Name is Ryan
Goodbye
```


<Aside>


### Using `endl` and `std::endl`


Another way of achieving line breaks, which you may see in other learning resources, involves streaming `endl` or `std::endl` to the output.  The following code shows an example of both:


```c++
#include <iostream>
using namespace std;

int main() {
  cout << "Hello World!";
  cout << endl;//<h>
  cout << "My Name is Ryan";
  cout << std::endl;//<h>
  cout << "Goodbye";
}
```


```c++
//<o>
Hello World!
My Name is Ryan
Goodbye
```


We'll tend to prefer the `\n` method, but we can consider either approach to be approximately equivalent.


Note however that the option of inserting the new line sequence in the middle of our text like `"Hello\nWorld"` is _**not**_ available when using `endl` or `std::endl`.  Those need to be streamed independently of any other content.


</Aside>


## Chaining `<<` Operators


We can stream multiple things to the terminal in a single statement.  This is done by using the `<<` operator multiple times, sometimes referred to as _**chaining**_ the operator:


```c++
#include <iostream>
using namespace std;

int main() {
  cout << "Hello World!" << "\n";//<h>
  cout << "My Name is Ryan" << "\n";//<h>
  cout << "Goodbye";
}
```


```c++
//<o>
Hello World!
My Name is Ryan
Goodbye
```


We can further shorten this program to a single statement.  The following statement spans multiple lines, and we've also added additional spaces to make our `<<` operators line up:


```c++
#include <iostream>
using namespace std;

int main(){
  cout << "Hello World!\n"
       << "My Name is Ryan\n"
       << "Goodbye";
}
```


```c++
//<o>
Hello World!
My Name is Ryan
Goodbye
```


Even though our statement now spans multiple lines, it is still a single statement.  We can tell when our statement ends by looking at where the semicolon is.


Breaking the statement across multiple lines and adding spaces to make our `<<` operators line up does not change the behaviour of the program.  However, laying our code out in a tidy way will make it easier to read for humans, including ourselves or our future colleagues.


## Outputting Numbers


We can output many different types of data. We will see more of this soon, but here's an example of outputting some numbers. Note that we don't need to surround numbers with quotes - we only use quotes when representing text:


```c++
#include <iostream>
using namespace std;

int main() {
  cout << 42 << " is a number\n"
       << "Another number is " << 3.14;
}
```


```c++
//<o>
42 is a number
Another number is 3.14
```


We should now have confirmed that our development environment is set up.  We can write code, compile it, run it, and see our output.


## Summary


In this introductory lesson, we have laid the groundwork for your journey into the world of coding. Here's a quick recap of what we've covered:

1. **Setting Up the Development Environment**: We should now have our environment set up, and be ready to start programming
2. **Creating a "Hello World" Program**: Our first coding exercise involved writing the classic "Hello World" program. This simple exercise ensured we have everything set up correctly, and served as an introduction to writing and running C++ programs
3. **Basic C++ Syntax**: We explored the basics of C++ syntax, covering how to write simple statements and use `cout` for output
4. **Understanding Line Breaks and Chaining Operators**: We learned how to format output using line breaks (`\n`) and the concept of chaining `<<` operators for streamlined code.
5. **Outputting Different Data Types**: The lesson concluded with an introduction to outputting various data types in C++, including both text and numbers.

<Preview>


### Objects, Types, and Variables


In our next lesson, we will begin exploring the core concepts of C++ programming. You'll learn about:

- **Objects and Types**: Understanding the fundamental building blocks of programming and how data is categorized.
- **Variables**: We will explore what variables are, and their role in helping to build more complex objects.
- **Data Types**: A closer look at different data types, including integers, floating-point numbers, and characters, and how they are used in programming.

This lays the foundation for more advanced topics, setting the stage for creating more complex programs.


</Preview>

Minor improvements to line break and number explanations

Updated IDE recommendations as CLion is now free for non-commercial use

Visual Studio

Xcode

Qt Creator

C & C++ Developer Tools

{UD}An easy-to-follow guide for setting up a C++ development environment. Ideal for beginners.

{CPP}Setting Up Your C++ Development Environment

Integrated Development Environments (IDEs)

Extended Character is not Valid in an Identifier

Setting up a C++ Development Environment

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Intro to C++ Programming

Questions & Answers