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>


By now, we're likely very comfortable formatting output, by chaining the `<<` operator.


We can combine strings with other variables to get the exact text output we want:


```c++
std::cout << "Health: " << Health << '\n';
```


There is another, more flexible approach to this, called _**string interpolation**_.


With string interpolation, we create a string containing specific character sequences that denote _**placeholders**_.  A string that includes placeholders to be used for interpolation is sometimes referred to as a _**format string**_.


Once we have our format string, we separately provide variables to be inserted into it, replacing the placeholders.


As of C++20, the main way of achieving this within the standard library is by using `std::format()`


</Excerpt>


<Ad />


## An Introduction to `std::format()`


`std::format` is available within the `<format>` header.


In its most basic usage, we provide it with a format string as the first argument.  That string should contain a placeholder marked `{}`.  We then provide a value to insert into that placeholder as a second argument:


```c++
#include <format>//<h>

int main(){
  std::format("I have {} apples", 5);//<h>
}
```


`std::format` returns a `std::string`, which we can store like any other variable, or stream to the console directly:


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

int main(){
  std::string Apples{
    std::format("I have {} apples", 5)};//<h>

  std::cout
    << Apples
    << std::format(" and {} bananas", 2);//<h>
}
```


```c++
//<o>
I have 5 apples and 2 bananas
```


Our format string can have any number of placeholders, which we can populate with values provided as additional arguments:


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

int main(){
  std::string Fruit{
    std::format(
      "{} apples, {} bananas, and {} pears",//<h>
      5, 2, 8)};//<h>

  std::cout << Fruit;
}
```


```c++
//<o>
5 apples, 2 bananas, and 8 pears
```


Naturally, our values are not restricted to literal integers.  We can provide any expression that results in a value of a type that is supported by `std::format`:


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

float CountBananas(){ return 2.5; }

int main(){
  int Apples{5};
  std::string Fruit{
    std::format(
      "{} apples, {} bananas, and {} pears",
      Apples, CountBananas(), "zero"//<h>
    )};

  std::cout << Fruit;
}
```


```c++
//<o>
5 apples, 2.5 bananas, and zero pears
```


<Ad />


## C++23's `std::print()`


C++23 introduced `std::print()`, which combines the effect of `std::format()` and directly sends the output to a stream, such as `std::cout`.


As such, code like this:


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

int main() {
  std::cout << std::format("{} apples", 5);//<h>
}
```


```c++
//<o>
5 apples
```


Can be written as:


```c++
#include <print>//<h>

int main(){
  std::print("{} apples", 5);//<h>
}
```


```c++
//<o>
5 apples
```


We'll stick to using `std::format()` in the rest of the examples because it's much more commonly used.  But, when working on a project where `std::print()` is supported, it's worth being aware that it is an option.


<Ad />


## Including Braces in a Template String


If we want to include literal `{` and `}` characters in our string when using `std::format()`, we duplicate them.


For example, if we want a single `{` to be output, our template string should contain `{{`:


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

int main(){
  std::string Fruit{
    std::format(
      "{} apples and some braces: {{ }}", 5//<h>
    )};

  std::cout << Fruit;
}
```


```c++
//<o>
5 apples and some braces: { }
```


<Ad />


## Positional Arguments


As we've seen, each placeholder marked `{}` corresponds sequentially to our variable values.  The first `{}` is replaced with the first value, the second `{}` is replaced by the second value, and so on.


We can control this by inserting integers between the braces, representing which value to use.  These positions are _**zero-based**_, which means we start counting from 0.


That means the first value has an index of `0`, the second has an index of `1`, and so on.    This is a fairly common convention in programming, and we'll see more examples of it later.


Providing these positional arguments allows us to control the order in which our values are used to generate the final string:


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

int main(){
  std::string Name{
    std::format("{1}, {0}", "James", "Bond"//<h>
    )};

  std::cout << Name;
}
```


```c++
//<o>
Bond, James
```


It also allows us to use the same value multiple times:


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

int main(){
  std::string Name{
    std::format("{1}, {0} {1}",//<h>
                "James", "Bond")};

  std::cout << Name;
}
```


```c++
//<o>
Bond, James Bond
```


<Ad />


## Formatting Specifiers


When we're inserting values into our format strings, we often can specify additional options, controlling how those values get inserted.


Within the placeholder, we pass options after a colon character `:`


For example, numeric types support the `+` specifier, which will prefix a `+` to the value, if the value is positive.  To use it, our placeholder would look like `{:+}` as shown below:


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

int main(){
  std::string Number{
    std::format("{:+}", 10)};//<h>

  std::cout << Number;
}
```


```c++
//<o>
+10
```


A placeholder's positional argument goes before the `:` so, when we're using both a positional argument and a format specifier, our placeholder would look like this:


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

int main(){
  std::string Number{
    std::format("{0:+}, {1:+}", 10, -42)};//<h>

  std::cout << Number;
}
```


```c++
//<o>
+10, -42
```


Which formatters are available depends on the type of the variable we're inserting into our string.


We'll cover the most useful specifiers of the built-in types, and how to use them, in the rest of this lesson.  A complete list of all options is available from one of the standard library references, such as [cppreference.com](https://en.cppreference.com/w/cpp/utility/format/formatter).


<Ad />


## Minimum Width Formatting


Passing a simple, positive integer as the format specifier sets the minimum width of that value within the string.


For example, inserting an integer like `3` into a string only requires one space.  But, if we set a minimum width of `6`, additional space will be added to ensure our variable uses at least 6 characters:


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

int main(){
  std::string Fruit{
    std::format("I have {:6} apples", 3)};//<h>

  std::cout << Fruit;
}
```


```c++
//<o>
I have      3 apples
```


The minimum width and alignment specifiers (covered later) are mostly useful when we're outputting multiple lines of text.


For example, if we're trying to create a table, we will want our columns to be vertically aligned.  Setting minimum widths can help us achieve that.


Below, we use these specifiers to create a table of 3 columns, with widths of `8`, `5`, and `6` respectively:


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

int main(){
  std::cout
    << std::format(
      "{:8} | {:5} | {:6} |",//<h>
      "Item", "Sales", "Profit")

    << std::format(
      "\n{:8} | {:5} | {:6} |",//<h>
      "Apples", 53, 8.21)

    << std::format(
      "\n{:8} | {:5} | {:6} |",//<h>
      "Bananas", 194, 33.89)

    << std::format(
      "\n{:8} | {:5} | {:6} |",//<h>
      "Pears", 213, 106.35);
}
```


```c++
//<o>
Item     | Sales | Profit |
Apples   |    53 |   8.21 |
Bananas  |   194 |  33.89 |
Pears    |   213 | 106.35 |
```


<Ad />


## Alignment and Fill Formatting


When our variable is an integer, we can prefix our minimum width value with a `0`.  This has the effect that any additional space inserted is filled by leading zeroes:


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

int main(){
  std::string Fruit{
    std::format("I have {:04} apples", 3)};//<h>

  std::cout << Fruit;
}
```


```c++
//<o>
I have 0003 apples
```


### Left, Center, and Right Alignment


We can prefix our width specifier with an additional character, specifying how our value should be aligned within that width.

- `<` denotes left alignment
- `^` denotes center alignment
- `>` denotes right alignment

For example, if we wanted our field width to be 12 spaces, and for our value to be centered within that space, our placeholder would be `{:^12}`


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

int main(){
  std::string Alignment{
    std::format("| {:^12} |",//<h>
                "Center")};

  std::cout << Alignment;
}
```


```c++
//<o>
|    Center    |
```


The following example shows the effect of the three alignment options:


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

int main(){
  std::string Alignment{
    std::format(
      "| {:<12} |\n| {:^12} |\n| {:>12} |",//<h>
      "Left", "Center", "Right"
    )};

  std::cout << Alignment;
}
```


```c++
//<o>
| Left         |
|    Center    |
|        Right |
```


We can additionally place a character before our alignment arrow, specifying what we want any additional space filled with.  Below, we fill the space with `-` characters:


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

int main(){
  std::string Alignment{
    std::format(
      "| {:-<12} |\n| {:-^12} |\n| {:->12} |",//<h>
      "Left", "Center", "Right")};

  std::cout << Alignment;
}
```


```c++
//<o>
| Left-------- |
| ---Center--- |
| -------Right |
```


<Ad />


## Float Precision


The most common formatting requirement when working with floating point numbers is to set their level of precision.


This is done using a `.` followed by the number of significant figures we want to be included in the resulting string:


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

int main(){
  float Pi{3.141592};
  std::cout
    << std::format("Pi: {:.1}", Pi)//<h>
    << std::format("\nPi: {:.3}", Pi)//<h>
    << std::format("\nPi: {:.5}", Pi);//<h>
}
```


```c++
//<o>
Pi: 3
Pi: 3.14
Pi: 3.1416
```


Below, we've combined this with a width argument (`8`) alongside right alignment using `>`, with any surplus space filled with `-` characters:


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

int main(){
  float Pi{3.141592};
  std::cout
    << std::format("Pi: {:->8.1}", Pi)//<h>
    << std::format("\nPi: {:->8.3}", Pi)//<h>
    << std::format("\nPi: {:->8.5}", Pi);//<h>
}
```


```c++
//<o>
Pi: -------3
Pi: ----3.14
Pi: --3.1416
```


<Ad />


## Using Variables in Format Specifiers


When we have a format specifier within a placeholder, we can sometimes additionally nest more placeholders within it.


This allows our variable's format specifiers to themselves use variables.


Below, we interpolate the argument at index `0` (that is, the integer `3`) into our string, setting the minimum width to the argument at index `1` (that is, the integer `4`):


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

int main(){
  std::string Number{
    std::format("I have {0:{1}} apples", 3, 4)};//<h>

  std::cout << Number;
}
```


```c++
//<o>
I have    3 apples
```


Positional arguments are optional here.  When omitted, the positions will be inferred based on the position of the opening `{` of each placeholder:


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

int main(){
  std::string Number{
    std::format("I have {:{}} apples", 3, 4)};//<h>

  std::cout << Number;
}
```


```c++
//<o>
I have    3 apples
```


<Ad />


## Date and Time Formatting (Chrono)


Earlier in the course, we covered the date and time utilities within the C++ standard library, called `chrono`


<LessonPromo url="intro-to-programming/dates-times-duration" title="Dates, Times and Durations" description="Learn the basics of the chrono library and discover how to effectively manage durations, clocks, and time points" />


Most of the Chrono types include support for `std::format()`:


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

int main(){
  using namespace std::chrono;
  time_point tp{system_clock::now()};

  std::cout << std::format("{}", tp);//<h>
}
```


```c++
//<o>
2023-12-05 14:59:34.8811286
```


They additionally have a large range of options for format specifiers, allowing us to customize date strings in highly elaborate ways:


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

int main(){
  using namespace std::chrono;
  time_point tp{system_clock::now()};

  std::cout
    << "Today is "
    << std::format(
      "{:%A, %e %B\nThe time is %I:%M %p}",//<h>
      tp
    );
}
```


```c++
//<o>
Today is Tuesday, 12 December
The time is 02:42 AM
```


A full range of all of the supported syntax is available from a standard library reference, such as [cppreference.com]([https://en.cppreference.com/w/cpp/chrono/system_clock/formatter](https://en.cppreference.com/w/cpp/chrono/system_clock/formatter)).


We cover the most commonly used options below:


```c++
#include <chrono>
#include <print>

int main(){
  using std::print;
  auto T {std::chrono::system_clock::now()};

  print("{:%c}", T);
  print("\n{:%R}", T);
  print("\n{:%r}", T);

  print("\n\nYear and Month");
  print("\nYear (4 digits): {:%Y}", T);
  print("\nYear (2 digits): {:%y}", T);
  print("\nMonth: {:%B}", T);
  print("\nMonth (3 chars): {:%b}", T);
  print("\nMonth (01-12): {:%m}", T);

  print("\n\nDay");
  print("\nDay of Month: {:%d}", T);
  print("\nDay (leading 0): {:%d}", T);
  print("\nDay of week: {:%A}", T);
  print("\nDay of week (3 chars): {:%a}", T);
  print("\n0 - 6 (0 = Sun, 6 = Sat): {:%u}", T);
  print("\n1 - 7 (1 = Mon, 7 = Sun): {:%w}", T);

  print("\n\nTime");
  print("\nHours (00-23): {:%H}", T);
  print("\nHours (1-12): {:%I}", T);
  print("\nAM / PM: {:%p}", T);
  print("\nMinutes (0-59): {:%M}", T);
  print("\nSeconds: (0-59): {:%OS}", T);
  print("\nTimezone: {:%Z}", T);
}
```


```c++
//<o>
12/05/23 14:33:46
14:33
02:33:46 PM

Year and Month
Year (4 digits): 2023
Year (2 digits): 23
Month: December
Month (3 chars): Dec
Month (01-12): 12

Day
Day of Month: 5
Day (leading 0): 05
Day of week: Tuesday
Day of week (3 chars): Tue
0 - 6 (0 = Sun, 6 = Sat): 2
1 - 7 (1 = Mon, 7 = Sun): 2

Time
Hours (00-23): 14
Hours (1-12): 02
AM / PM: PM
Minutes (0-59): 33
Seconds: (0-59): 46
Timezone: UTC
```


<Ad />


<Preview>


### Using `std::format()` and `std::print()` with Custom Types


The mechanisms that underpin `std::format()` and `std::print()` are designed such that any type can implement support for them.  We saw an example of this with chrono `time_point` objects, but this is not restricted to standard library types.  Our user-defined types can also implement support for `std::format()` and `std::print()`.


For example, we could enable a user-defined `Character` type to be compatible with standard library formatting, including format specifiers.


Anyone using our class could then easily interpolate a `Character` object's data members into their string, perhaps using code like this:


```c++
int main(){
  Character Player;
  std::format(
    "I have {0:H} health and {0:M} mana", Player//<h>
  );
}
```


Enabling this requires knowledge of templates - an advanced C++ concept that we cover in the next course.


</Preview>


## Summary


In this lesson, we explored the `std::format()` and `std::print()` functions added in C++20 and C++23.  These allow us to perform _**string interpolation**_.  The key topics we covered include:

- String interpolation in C++ using `std::format()`, enabling dynamic insertion of variables into strings.
- Understanding the usage of formatting specifiers for precise control over string output.
- Familiarity with `std::print()` in C++23 for streamlined output formatting.
- Techniques for including braces and using positional arguments in format strings.
- Application of `std::format()` with various data types, including `chrono` objects for date and time formatting.

<Preview>


### Overloading the `<<` Operator


In our upcoming lesson, we'll revisit operator overloading, specifically focusing on overloading the `<<` operator. This will enable us to seamlessly stream our custom types to `std::cout`.


</Preview>

`std::format` in C++20

`std::formatter`

`std::formatter<std::chrono::sys_time>`

`std::print`

{CPP}A detailed guide to string formatting using std::format from C++20, and std::print from C++23

{CPP}String Interpolation in Modern C++ using std::format and std::print

Using `std::format()` and `std::print()` with Custom Types

String Interpolation

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Intro to C++ Programming