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 the real world, C++ projects can get very large.  They can contain thousands of source files, being collaborated on by multiple teams of people.


In these scenarios, we need to be extra-mindful of how our project is organized.  We don't want the work we're doing in our part of the program to conflict with or restrict what is possible in some other component.


For example, if we create a simple variable in one of our files, nobody else can create a variable with the same name, in any of the thousands of other files our program might contain.


Doing so would be a violation of the _**one definition rule**_, which we introduce later in this lesson.  Both of the following files will compile successfully but, once the output is sent to the linker, it will notice the problem and raise an error:


```c++
// SomeFile1.cpp
float Pi{3.14};
```


```c++
`// SomeFile2.cpp
float Pi{3.14};
```


```c++
//<oe>
SomeFile2.cpp.obj : error LNK2005: "float Pi" already defined in SomeFile1.obj
```


Another issue we'll encounter when working on such large projects is a simple human readability problem.


When we have a file that is creating an object from a `Character` class, or callling a function called `CalculateArea()`, which part of our project are those symbols coming from?  When our project has dozens of components split across thousands of files, it's not always clear what we're using.


To solve both of these problems, we use _**namespaces**_.


## Creating a Namespace


We can wrap sections of our code inside a `namespace` as shown below.  Here, we create a namespace called `Geometry`:


```c++
namespace Geometry {
  // your code here
}
```


We can populate namespaces with classes, functions, variables, and any of the constructs we've seen before:


```c++
namespace Geometry {
  float Add(float x, float y) {
    return x + y;
  }

  float Pi { 3.14 };

  class Square {
    float SideLength { 5.0 };
    float Area() {
      return SideLength * SideLength;
    }
  };
}
```


<Quiz title="Creating Namespaces">


<Question>


How can we create a namespace called `Utilities`?


<Answer>


`using namespace Utilities;`


<Feedback>


Not quite. Think about how we define a new namespace.


</Feedback>


</Answer>


<Answer isCorrect>


`namespace Utilities {};`


<Feedback>


Excellent! This is the correct syntax for defining a new namespace in C++


</Feedback>


</Answer>


<Answer>


`Utilities {};`


<Feedback>


This syntax isn't used for creating namespaces in C++. Reflect on how the 'namespace' keyword is utilized in the examples


</Feedback>


</Answer>


</Question>


</Quiz>


<Ad />


## Accessing Identifiers Inside Namespaces


As usual with `{` and `}`, namespaces define a new scope.  Expressions within the namespace can access other namespace members as usual:


```c++
namespace Geometry {
  float Pi { 3.14 };
  float Circumference(float Diameter) {
    // We can access Pi here as we're in
    // the same scope / namespace
    return Diameter * Pi;
  }
}
```


To access namespace members from outside the namespace, we need the _**Scope Resolution Operator**_, which has two colons `::`


For example, the following statement accesses the `Add` function and the `Pi` variable, which are both inside the `Geometry` namespace:


```c++
namespace Geometry {
  float Add(float x, float y) {
    return x + y;
  }

  float Pi { 3.14 };
}

int main() {
  Geometry::Add(10, Geometry::Pi);
}
```


<Quiz title="The Scope Resolution Operator">


<Question>


How can we call the `Greet` function within the `Utilities` namespace?


```c++
namespace Utilities {
  void Greet() {
    cout << "Hi!";
  };
};
```


<Answer>


`Utilities.Greet();`


<Feedback>


This syntax resembles object method access, but remember how we access elements within a namespace


</Feedback>


</Answer>


<Answer>


`Utilities->Greet();`


<Feedback>


The arrow operator is used with pointers, not for accessing namespace members. Think about the correct operator for namespaces


</Feedback>


</Answer>


<Answer isCorrect>


`Utilities::Greet();`


<Feedback>


Well done! Using the scope resolution operator `::` is the correct way to access members of a namespace


</Feedback>


</Answer>


</Question>


</Quiz>


## Nested Namespaces


In particularly complex projects, even one of our namespaces can get extremely large, containing hundreds or thousands of identifiers.  To solve this, we can essentially repeat the process - adding namespaces to our namespace.


That is, namespaces can be nested inside other namespaces.  Below, we have a namespace called `Constants` within a namespace called `Geometry`:


```c++
namespace Geometry {
  float Add(float x, float y) {
    return x + y;
  }
  namespace Constants {
    float Pi { 3.14f };
  }
}
```


To access these nested identifiers, we can use the `::` operator multiple times:


```c++
Geometry::Add(10, Geometry::Constants::Pi)
```


<Aside>


### Namespaces vs Classes


A common question people have when deciding how to organize code in C++ projects is when to use a namespace and when to use a class.  The main conceptual difference is that classes can create objects, whilst namespaces cannot.


It doesn't make sense to create an object with a type of "Geometry".  So, for this type of organization, we can create a namespace instead.


Those coming from other programming languages may be familiar with the concept of a static class, which is how these problems are sometimes solved in those programming languages.


C++ also allows class members to be static, which we'll cover soon.


However, in most scenarios, solving this problem directly using namespaces tends to be the preferred approach in C++.
</Aside>


## The One Definition Rule (ODR)


Once we create a namespace and `#include` it in other files, we'll quickly begin to see linker errors relating to symbols already being defined.  The following simple 3-file program recreates this:


```c++
// Geometry.h
#pragma once

namespace Geometry {
  float Pi{3.14};
  float Circumference(float Diameter) {
    return Diameter * Pi;
  }
}
```


```c++
// main.cpp
#include "Geometry.h"

int main() {}
```


```c++
// SomeFile.cpp
#include "Geometry.h"
```


```c++
//<o>
main.cpp.obj : error LNK2005: "float Geometry::Circumference(float)" already defined in SomeFile.obj
main.cpp.obj : error LNK2005: "float Geometry::Pi" already defined in SomeFile.obj
```


To solve this, we can split our namespace into a header file and source file, in much the same way we have shown with classes.


Our declarations remain in `Geometry.h` whilst we move definitions to `Geometry.cpp`, as in the following example.  Note we explain the meaning of `extern` in the next section:


```c++
// Geometry.h
#pragma once

namespace Geometry {
  extern float Pi;
  float Circumference(float Diameter);
}
```


```c++
// Geometry.cpp
#include "Geometry.h"

float Geometry::Pi{3.14};
float Geometry::Circumference(float Diameter) {
  return Diameter * Pi;
}
```


<Aside>


### The `extern` keyword


When we're forward declaring a function that will be defined externally, the compiler can implicitly understand that's what we're doing.  When a function has no body, the compiler understands we're not defining the function - we're just declaring it.


With variables, we need to do a little extra work.


A statement like `int MyInt;` defines a variable.  Specifically, we're defining it to be whatever is the result of calling the default constructor of that type.  In this case, we're defining `MyInt` as `0`.


When we intend to forward-declare a variable that is defined externally, in some other file, we need to clarify that intent by adding the `extern` keyword.


</Aside>


<Aside>


### The `inline` keyword


As of C++17, we also have the option of marking the members `inline` rather than moving their definition to a dedicated file:


```c++
// Geometry.h
#pragma once

namespace Geometry {
  inline float Pi{3.14};//<h>
  inline float Circumference(float Diameter) {//<h>
    return Diameter * Pi;
  }
}
```


If the compiler receives multiple definitions of an `inline` member, it simply chooses one and discards the others.


This is intended to specifically solve multiple definitions caused by the `#include` directive.  In such scenarios, it doesn't matter what definition the compiler chooses.  All the definitions trace back to the same file (the file we're including) so they will all be the same.


We cover `extern`, `inline`, and related topics in more detail in the next course.


</Aside>


<Aside>


### Class Declarations and the One-Definition Rule


A common point of confusion at this point is why our class definitions haven't infringed on the one definition rule when we include their headers in multiple files.


For example, it would seem like a class like this would generate multiple definitions of the `Health` variable when included in multiple files:


```c++
// Character.h
#pragma once

class Character {
public:
  int Health{100}
};
```


But when we define a class member in this way, the variable is not technically part of the class.  It is simply a recipe for creating instances of a variable that will exist on objects created using the class.


On a namespace, however, we are generating a single variable, accessible using a specific identifier like `Geometry::Pi`.  There will only ever be one instance of that variable in our program, so we can only have one definition for what its value should be.


It is possible to create class variables that behave like namespace variables.  These are called _**static class members**_, which we'll introduce in the next course. 


</Aside>


<Ad />


## Adding to Namespaces


In complex projects, namespaces can get quite large.  They can include multiple classes, for example.  As such, it is common for the contents of a namespace to span multiple files.


Below, we create a namespace containing two classes, where each class is declared within a dedicated file:


```c++
// Square.h 
#pragma once

namespace Geometry {
  class Square{};
}
```


```c++
// Circle.h 
#pragma once

namespace Geometry {
  class Circle{};
}
```


```c++
// main.cpp
#include "Circle.h"
#include "Square.h"

int main() {
  Geometry::Circle MyCircle;
  Geometry::Square MySquare;
}
```


Where we're providing a full declaration of our namespace within a header file, we can alternatively provide class definitions by including that header file and then using the `::` operator like this:


```c++
// Geometry.h
#pragma once

namespace Geometry {
  class Circle;
}
```


```c++
// Circle.h
#pragma once
#include "Geometry.h"

class Geometry::Circle {//<h>

};
```


When our class is within a namespace, our source files for that class can provide function definitions using either the `namespace` syntax, or the `::` operator:


```c++
// Square.h
#pragma once

namespace Geometry {
  class Square{
   public:
    float Area();
    float Perimeter();

  private:
    float SideLength;
  };
}
```


```c++
// Square.cpp
#include "Square.h"

// Option 1:
namespace Geometry {
  float Square::Area() {
    return SideLength * SideLength;
  }
}

// Option 2:
float Geometry::Square::Perimeter() {
  return SideLength * 4;
}
```


## Anonymous Namespaces


Previously, we introduced the concept of _**global variables**_.  These are variables that are added to our files, outside of any scope.  In the following example, `Pi` is a global variable:


```c++
// main.cpp
float Pi;

int main() {}
```


We saw how the linker can link a definition in one file to its use in another.


However, this presents a problem when there are multiple definitions of the same identifier. 


For example, if we create a global `Pi` variable in another file, our program will no longer link correctly:


```c++
// Geometry.cpp
float Pi;
```


```c++
//<oe>
main.cpp.obj : error LNK2005: "float Pi" already defined in Geometry.obj
```


This is again a violation of the _**one-definition rule**_ (ODR).


If we intend to forward-declare a variable that will be defined in some other file, we can add the `extern` keyword as described above:


```c++
// Geometry.cpp
float Pi { 3.1415 };
```


```c++
// main.cpp
#include <iostream>
using namespace std;

extern float Pi;//<h>

int main() {
  cout << "Pi as defined in some other file: "
    << Pi;
}
```


```c++
//<o>
Pi as defined in some other file: 3.1415
```


If we intend to create a variable that we can use anywhere in the current file, without affecting any other file, we can solve the problem using an _**anonymous namespace**_.


Predictably, an anonymous namespace is a namespace without a name:


```c++
namespace {
  float Pi { 3.14 };
}
```


Identifiers defined within an anonymous namespace are only available to the same source file where the namespace exists.


Therefore, we can think of an anonymous namespace as the "private" section of a file.


```c++
// Geometry.cpp
namespace {
  float Pi{3.1415};
}

float GetPi() { return Pi; }
```


```c++
// main.cpp
#include <iostream>
using namespace std;

namespace {
  float Pi{3.14};
}

// Forward declaring a function defined
// in Geometry.cpp
float GetPi();

int main() {
  cout << "Pi in main.cpp: " << Pi
    << "\nPi in Geometry.cpp: " << GetPi();
}
```


```c++
//<o>
Pi in main.cpp: 3.14
Pi in Geometry.cpp: 3.1415
```


## Summary


This lesson provided an introduction to _**namespaces**_, covering their creation, usage, and significance in organizing code.


**Key Takeaways:**

- How to create and use namespaces to organize code and avoid identifier conflicts.
- The role of the scope resolution operator **`::`** in accessing namespace members.
- The concept of nested namespaces and how they can be used for further organization.
- The importance of the One Definition Rule (ODR) in namespaces and strategies to adhere to it using the **`extern`** and **`inline`** keywords.
- The distinction between namespaces and classes in C++, and the introduction to anonymous namespaces for file-specific usage.

<Preview>


### Using Enums


In our next lesson, we'll explore _**enums**_. Enums, or enumerations, are yet another way to create user-defined types, but they are much simpler than classes and structs.


They are particularly useful in scenarios when we need to create variables that have a value from a limited range of possibilities, which we can define.


**Key Topics:**

- Understanding the basic concept of enums and their role in programming.
- Learning how to define and use enums to represent a collection of related values.
- Exploring the benefits of using enums for code readability and maintenance.

</Preview>

Expanded introduction and explanation of nested namespaces reinforce why they are useful

Namespace - C++ Reference

Namespace - Wikipedia

Namespaces (C++) - Microsoft Docs

Namespace Definition - C++ Tutorial

{CPP}Beginner-friendly guide to C++ namespaces: Discover how to use and manage namespaces

{CPP}Understanding C++ Namespaces

Class Declarations and the One-Definition Rule

Namespaces

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Intro to C++ Programming