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

<Excerpt>


In the previous lesson, we constructed a list like this, to show some of the data we would need to describe one of our monsters:


| Data Type | Variable Name | Description                                | Example            |
| --------- | ------------- | ------------------------------------------ | ------------------ |
| bool      | `isAlive`     | Is the monster currently alive?            | `false`            |
| int       | `Health`      | How much health the monster has remaining  | `150`              |
| float     | `Armor`       | How much damage resistance the monster has | `0.2`              |
| string    | `Name`        | The monster's name                         | `"Goblin Warrior"` |


In this lesson, we will see how we can create the variables to store this data.


</Excerpt>


<Ad />


Let's start with the `bool` that represents whether or not the monster is currently alive:


```c++
bool isAlive;
```


This line is an instruction that we want to create a variable of type `bool`, and we will be using the name `isAlive` to identify it. Remember, an instruction like this is called a **statement** and, in C++, we end each statement with a semicolon `;`


This statement will cause our program to make a request to the operating system, asking that we be allocated some space in memory. Specifically, it is requesting enough memory to store a boolean value.


From then on, we can use the `isAlive` identifier any time we want to access the data stored in that memory location.


<Quiz title="Creating Variables">


<Question>


How can we create an integer variable called `Health`?


<Answer>
`Health int;`
<Feedback>


Almost there! Remember, in C++, the correct syntax for declaring a variable is to start with the type followed by the variable name.


</Feedback>


</Answer>


<Answer isCorrect>


`int Health;`


<Feedback>


You got it!


</Feedback>


</Answer>


<Answer>


`var Health;`


<Feedback>


This looks like a variable declaration, but `var` isn't a type in C++. In C++, you need to specify the exact data type of the variable.


</Feedback>


</Answer>


</Question>


</Quiz>


<Ad />


## Code Comments


By using `//` in our code, we can add a **comment**.


```c++
// Is the monster currently alive?
bool isAlive;
```


Comments are mainly to help developers describe in plain language what their code is doing, and why. They are ignored by the processes that convert our code into an executable.


Anything after the `//` on a line of code is treated as a comment. In the above example, the entire line is a comment.  But comments can also be on the same line as functional code:


```c++
bool isAlive; // This is a comment
```


As an alternative to a line comment using `//`, we can also place comments between `/*` and `*/` tokens:


```c++
bool isAlive; /* This is a comment */
```


This style of comment can span multiple lines:


```c++
/*
This is a comment
on multiple lines
*/
bool isAlive;
```


It can even go in the middle of a line of functional code, although this is not commonly used:


```c++
bool /* This is a comment */ isAlive;
```


We'll use comments quite a lot in the code samples of this lesson to explain what is happening.


It is often worth adding comments to your code too, especially as a beginner. They can help you get back up to speed if you come back to your code later, and need a reminder of what certain lines are doing.


<Ad />


## Variable Values


Once we have created a variable, we can store a value in it like this:


```c++
// Is the monster currently alive?
bool isAlive;
isAlive = false;
```


The `isAlive = false;` statement updates our `isAlive` variable to have the value of `false`.


<Aside>


### The Assignment Operator


The `=` symbol is our second example of an operator.  It is typically called the _**assignment operator**_.


Much like the `<<` operator we introduced in the first lesson, `=` has two _**operands**_ - one on the left, and one on the right.  The effect of the operator is to visit the memory location identified by the left operand, and update it with the value of the right operand.


</Aside>


<Error>


### Use of Undeclared Identifier


This error occurs when you're trying to access a variable, and C++ doesn't know what that variable is.  There are two common causes for this error:


**We're trying to create a variable but did not include the type**


To create a variable, we need to specify the type.  `bool isAlive;` will create a variable, but `isAlive` will try to access a variable that was already created.


**The variable name is not correct**


Like most programming languages C++, is case sensitive.  Capitalisation matters.


For example, `isAlive`, `IsAlive`, and `isalive` are all different names.  If we want to access a variable we previously created, we need to use the same name we used when we created it.


</Error>


We can provide an initial value for a variable at the same time we first declare it. This is called _**initializing**_ the variable.  This code will request the operating system give us enough space in the system's memory to store a boolean, and initialize that boolean to contain the value of `false`:


```c++
// Is the monster currently alive?
bool isAlive { false };
```


The `{` and `}` characters are commonly called _**braces**_ and are used a lot in programming.  On US/UK keyboard layouts, they are typically to the right of the _P_ key.


When initializing a variable with a value, we can also do it with the `=` symbol


```c++
// Is the monster currently alive?
bool isAlive = false;
```


<Aside>


### The Many Ways to Initialize C++ Variables


We've already seen two different ways to initialize variables in C++


**Copy initialization** uses the `=` operator:


```c++
bool isAlive = false;
```


**Uniform initialization** uses the `{}` syntax:


```c++
bool isAlive { false };
```


There are even more ways, but these two are the most common.   `=` was historically used, and is generally going to be the most familiar to people coming from other programming languages.


We'll prefer uniform initialization using `{` and `}` in this course, but, for now, we can consider either approach to be approximately equivalent.  There are some minor differences, but we will point them out later, when we encounter scenarios where those differences matter.


</Aside>


Creating variables of other types, such as `int` and `string`, follows the same pattern:


```c++
int Level { 5 };

// Remember, strings need wrapped in double quotes
string Name { "Goblin Warrior" };
```


<Quiz title="Initializing Floats">


<Question>


How might we initialize a floating point variable called `Armor`?


<Answer isCorrect>
`float Armor { 0.4 };`
<Feedback>


You got it!


</Feedback>


</Answer>


<Answer>


`float Armor => 0.4;`


<Feedback>


Nice try, but the `=>` syntax isn't used in C++ for variable initialization. Instead, use either `=` or braces `{}`.


</Feedback>


</Answer>


<Answer>


`Armor { 0.4 };`


<Feedback>


You're close! Just remember to specify the type of the variable when declaring it.


</Feedback>


</Answer>


</Question>


</Quiz>


## Outputting Variables


In the first lesson, we were working with this basic code structure to stream information to the console.


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

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


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


Let's see how our variables integrate with this.  Until we learn more, I'd suggest creating all our variables _**after**_ the `using namespace std;` line, and doing all `cout` statements between the `{` and the `}` of the `main` code block.


<Aside>


### Code Highlighting


Within the code samples we show, we will sometimes highlight specific lines of code.  The lines we want to draw your attention to are highlighted in green:


```c++
int LookAtMe { 5 };//<h>
```


Lines that contain an error are highlighted in red:


```c++
int ThisWontWork { "Hello World!" };//<e>
```


Sometimes, a line of code will technically work, but isn't something we should do because it can make our code confusing or has other design issues.  We'll highlight those lines in orange:


```c++
int DontDoThis { true };//<w>
```


</Aside>


The following is an example of a program using our new knowledge of variables:


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

string Name { "Goblin Warrior" };//<h>
int Level { 10 };//<h>

int main() {
  cout << "The monster's name is "<< Name;//<h>
  cout << "\nand its level is " << Level;//<h>
}
```


When we compile and run this, we should see a message like this logged out to the terminal:


```c++
//<o>
The monster's name is Goblin Warrior
and its level is 10
```


Note, if we try to `cout` boolean values, you might not get what you expect.  `true` will log out as `1` and `false` will log out as `0`.  That's not very useful right now, but we will explore booleans in more detail soon.


<Ad />


<Error>


### Redefinition of Variable


One of the most common errors we will make with variables is repeating the type when trying to update a variable that was already created.


This error will generally be reported in our IDE using wording like `redefinition of (your variable name)`


We only need to set the type of the variable when we first create it.


The following would be invalid code, as it is attempting to create two different variables, using the same name:


```c++
bool isAlive;

// Error!  We already have a variable called "isAlive"
bool isAlive = false;//<e>
```


When we want to access or update a variable we already created, we just use the name, not the type:


```c++
bool isAlive;

isAlive = false;//<h>
```


</Error>


<Error>


### Expected ; After Expression


Another common error is misuse of the brace syntax.  We only use `{` and `}` to initialize a variable, not to update it.


Therefore, the following example would also generate an error, which will generally be reported as something like `Expected ; after expression`:


```c++
bool isAlive { false };

// Error! This brace syntax is only for initialization
isAlive { true };//<e>
```


We should use `=` to update a variable


```c++
bool isAlive { false };

isAlive = true;
```


</Error>


## Copying Variables


We can initialize a variable using the value of another variable.


In the below code, we are copying the value of the `MaxHealth` variable into a new variable called `CurrentHealth`.


```c++
int MaxHealth { 150 };
int CurrentHealth { MaxHealth };
```


After this code runs, we will have two variables that initially have the same value, but can then be updated individually.


## More Examples


The code sample below shows more examples of how we can create and work with variables.


```c++
//<show-line-numbers>
// Initialise a new integer variable
int Health { 150 };

// We can also initialize a variable using =
int ExperienceLevel = 1;

/*
We can update the value of an existing
variable later in our code using the = operator
*/
Health = 200;

// We can copy booleans too
bool isAlive { false };
bool canAttack { isAlive };

/*
Remember, we don't redeclare the variable's
type when we update its value.  We only
declare its type when we first create it.
Line 24 is an error because Health
was already initialized
*/
int Health = 250; // error!//<e>

/*
When updating a variable, we cannot
use the { braces } syntax.  Braces are only
used for initialization.  Therefore,
line 32 will cause an error
*/
ExperienceLevel { 3 }; // error!//<e>
```


<Aside>


### Line Numbers


The previous code snippet shows **line numbers** to the left.  In the above example, the line numbers go from 1 to 32.


Line numbers are not part of the language, and should not be included in our code.  They simply give us an easy way to communicate which parts of our code we're talking about.


For this reason, they're commonly enabled in our IDEs by default, and we'll sometimes show them in our code examples in this course where doing so is helpful.


</Aside>


## Summary


In this lesson, we've covered several key aspects of creating and updating variables in C++. Here's a quick recap:

- **Variable Creation**: We learned how to declare variables in C++ using various data types like `bool`, `int`, `float`, and `string`.
- **Understanding Statements**: We explored the concept of a statement in C++, focusing on its structure and the necessity of ending each statement with a semicolon.
- **Memory Allocation**: Discussed how declaring a variable requests memory space and how the variable name/identifier allows us to re-access this memory later.
- **Using Comments**: We introduced how to use comments (`//` and `/* ... */`) to make code more readable and understandable.
- **Initializing Variables**: The lesson covered initializing variables with values using `=` and braces `{}`.
- **Error Handling**: We introduced common errors such as 'Use of undeclared identifier' and 'Redefinition of variable', and how to avoid them.
- **Outputting Variables**: Demonstrated how to output variable values to the console using `cout`.
- **Copying Variables**: Explored initializing variables using the value of other variables, and how they can be updated individually.

<Preview>


### Numbers


In our next lesson, we will shift our focus to **Numeric Variables**. This upcoming lesson will explore:

- **Different Numeric Types**: Understanding the variety of numeric data types in C++, like `int` and `float`, and their usage.
- **Arithmetic Operations**: We will learn how to perform basic arithmetic operations with numeric variables.

Let's continue our initial exploration of variables by looking at numbers in more depth!


</Preview>

Removed reference to `double` in the preview section

Fundamental Data Types in C++

Declarations and Definitions in C++

C++ Declarations

C++ Variables Guide

C++ Variable Declaration

{CPP}Discover the basics of C++ variables in our beginner's lesson

{CPP}C++ for Beginners: Creating & Updating Variables

The Many Ways to Initialize C++ Variables

Creating Variables

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Intro to C++ Programming