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>


Our software often needs to deal with dates, times, and durations.  This lesson gives a brief introduction to the most useful utilities within C++ to deal with these requirements.  In C++, the `chrono` library is the main way we implement these features.


We can `#include` the library and access its functionality through the `std::chrono` namespace.


```c++
#include <chrono>

using namespace std::chrono;
```


In this lesson, we will cover 3 aspects of `chrono` - durations, clocks, and time points


</Excerpt>


## Chrono Durations


A `std::chrono::duration` is a period of time, such as two weeks, one hour, or 1 minute and 30 seconds. The `chrono` library gives us a range of functions to express durations, such as `std::chrono::weeks`, `std::chrono::seconds`, and more:


```c++
#include <chrono>

int main() {
  using namespace std::chrono;
  duration Duration1 { weeks(2) };
  duration Duration2 { hours(5) };
  duration Duration3 { milliseconds(100) };
}
```


The `duration` type has overloaded the arithmetic operators such as `+` and `*=`, allowing us to combine durations in intuitive ways:


```c++
#include <chrono>

int main() {
  using namespace std::chrono;

  // Add durations together
  duration Duration { weeks(2) + days(4) };

  // Increase an existing duration
  Duration += days(2);

  // Doubling an existing duration
  Duration *= 2;
}
```


We can also compare durations using comparison operators such as `>` and `<=`:


```c++
#include <chrono>

int main() {
  using namespace std::chrono;

  duration Duration { weeks(2) + days(4) };

  // This will be true
  if (Duration > days(15)) {//<h>
    // ...
  }
}
```


<Ad />


### Duration Literals


Duration literals are available.  These require us to have an appropriate `using namespace` statement in place.  Options include:

- `using namespace std::chrono;`
- `using namespace std::chrono_literals;`
- `using namespace std::literals;`

In scopes where an appropriate `using` statement is in effect, we can then express durations using literals such as `h`, `min` and `s`:


```c++
#include <chrono>

int main() {
  using namespace std::chrono;
  duration Hours{5h};
  duration Minutes{5min};
  duration Seconds{5s};
  duration Milliseconds{5ms};
  duration Microseconds{5us};
  duration Nanoseconds{5ns};
}
```


### Duration `count()`


The underlying numeric value within a duration is available using the `count()` method:


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

int main() {
  using namespace std::chrono;
  duration Duration{5h};
  std::cout << Duration.count() << " Hours";//<h>
}
```


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


### Changing Units Using `duration_cast()`


The `duration_cast()` function allows us to convert a duration into an equivalent duration, but using a different unit of measurement.


In the following example, we convert `1.5` hours to minutes, which results in a `count()` of `90` as we'd expect:


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

int main() {
  using namespace std::chrono;
  duration Duration{1.5h};
  duration Minutes{
    duration_cast<minutes>(Duration)};//<h>

  std::cout << Minutes.count() << " Minutes";
}
```


```c++
//<o>
90 Minutes
```


<Ad />


### Using a `duration` to Pause Execution


In combination with the `<thread>` library, we can use durations to cause our application to go to sleep for some time.  This is available as the `sleep_for()` function on `std::this_thread`, which we have access to if we `#include <thread>`


Below, we use this to insert a 5-second pause between the "Starting" and "Done" logs:


```c++
#include <chrono>
#include <iostream>
#include <thread>//<h>

int main() {
  using namespace std::chrono;

  std::cout << "Starting\n";
  std::this_thread::sleep_for(5s);//<h>
  std::cout << "Done!";
}
```


```c++
//<o>
Starting
Done!
```


## Chrono Clocks


A clock is a source of time information.  By default, chrono offers 3 clocks:

- The `system_clock` uses data from the operating system's built-in clock. For most cases, using this is the simplest approach.
- The `steady_clock` is designed not to be impacted by changes to the system clock. Use this if it is important that users cannot exploit our software by changing their system clock.
- The `high_resolution_clock`, which is designed to be highly accurate. Use this if we require millisecond, microsecond, or nanosecond-level accuracy. This can be useful when measuring performance, for example.

## Chrono Time Points


Using data from a clock, we can generate a value representing a specific point in time.  Chrono represents time points using the `std::chrono::time_point` type.  For example, to get the current time point from the system clock, we can do this:


```c++
#include <chrono>

int main() {
  using namespace std::chrono;
  time_point CurrentTime {
    system_clock::now()//<h>
  };
}
```


We can also add or remove durations to time points.  Below, we generate a time point 3 weeks in the past:


```c++
#include <chrono>

int main() {
  using namespace std::chrono;
  time_point ThreeWeeksAgo {
    system_clock::now() - weeks(3)
  };
}
```


We can generate a `duration` by comparing time points using the `-` operator.  Below, we generate two time points, approximately 5 seconds apart.  We then store the difference between those two time points as a `duration`, which we output as milliseconds using `duration_cast()`:


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

int main() {
  using namespace std::chrono;

  time_point StartTime{system_clock::now()};
  std::this_thread::sleep_for(seconds(5));
  time_point EndTime{system_clock::now()};

  // Create a duration from two time points
  duration RunningTime{EndTime - StartTime};//<h>

  std::cout << "Time difference in ms: "
    << duration_cast<milliseconds>(
      RunningTime).count();
}
```


```c++
//<o>
Time difference in ms: 5007
```


<Ad />


<Aside>


### Clock Drift


There is something to bear in mind when using `sleep_for()`, and almost any other way of causing our application to pause.


That is, our applications will always sleep for _**slightly longer**_ than we requested.  This is due to a nuance in how operating systems schedule processes.  We should consider `sleep_for()` to be an instruction to "sleep for _**at least**_ this amount of time".


In the previous program, we asked our application to sleep for 5 seconds, but it will typically sleep for around 5.007 seconds.


In most use cases, these fractions of a second don't matter - however, in some scenarios, they do.  For example, if we create a long-running program that needs to be updated every second, we might use a loop that includes a `sleep_for(1s)` statement.  However, if our loop iterations are delayed by 0.007 seconds on average, our program would lose around 10 minutes of accuracy every day.


For these scenarios, we need to compensate for the drift.  A common way of doing this is to compare the current time point to the time point from the previous iteration of the loop, and adjust our `sleep_for()` argument accordingly.


For example, if we find the time points are 1.01 seconds apart, our next `sleep_for()` call should only be for 0.99 seconds.  This causes our program to self-correct, and remain accurate even when running for long periods.
</Aside>


## Using `std::time_t`


Chrono is a relatively new addition to the language.  C++ has an older way of representing times, which is still commonly used.  These times are typically stored using the `std::time_t` type, and we'll need to be able to interact with both.


Our Chrono clocks have functions that allow us to generate `std::time_t` objects from `chrono::time_point` objects.  When we're using the `system_clock`, we can call the `system_clock::to_time_t()` function.  


Below, we're using this to store the current time in a `std::time_t` called `Time`:


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

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

  std::time_t Time {//<h>
    system_clock::to_time_t(StartTime)//<h>
  };//<h>

  std::cout << Time;
}
```


This will output a number, similar to this:


```c++
//<o>
1651075702
```


<Aside>


### Unix Time


The previous output is an example of a UNIX timestamp.   This is a commonly used convention when computer systems communicate dates and times with each other.


A Unix timestamp treats any point in time as a single integer.  That integer represents the number of seconds between the chosen date, and 00:00:00 UTC on 1st January 1970, sometimes referred to as the _**Unix epoch**_


Websites such as [unixtimestamp.com](http://unixtimestamp.com/) allow us to convert human-readable dates to Unix timestamps, and vice versa.  We'll see how to do this within our program later in this lesson.  


</Aside>


<Aside>


### Creating a `time_point` from a `time_t`


The previous example showed how we can create a `time_t` from a chrono `time_point`.  We can also go in the opposite direction, creating a `time_point` from a `time_t` by using the `from_time_t()` functions:


```c++
void HandleTime(std::time_t T) {
  using namespace std::chrono;
  time_point TP{system_clock::from_time_t(T)};
  // ...
}
```


</Aside>


## Date and Time Structs (`tm`)


A Unix timestamp is enough to represent a time, but it's not a particularly friendly format to work with.  An alternative way time points are stored is as `tm` structs.  These represent dates and times in terms of their components - years, months, hours, etc.


Interpreting our `std::time_t` in this way involves two parts:

- The standard library's `tm` struct gives us a way to create an object for storing these individual components.  Our object will have member variables like `tm_year`, `tm_hour`, `tm_min`, and more.  The complete list of its variables, and what they mean, are available on a standard library reference such as [cppreference.com](https://en.cppreference.com/w/c/chrono/tm).
- The `localtime_r()` function populates a `tm` object.  This function takes two arguments.  The first is a pointer to our `time_t`.  The second argument is a pointer to the `tm` which it will populate:

```c++
localtime_r(&TimePoint, &TimeContainer);
```


<Error>


### `localtime_r()` Not Found on Windows


When compiling on Windows, the `localtime_r()` function may result in compilation errors.  This can be addressed by using `localtime_s()` instead, and switching the order of the arguments:


```c++
// Before
localtime_r(&TimePoint, &TimeContainer);//<e>

// After
localtime_s(&TimeContainer, &TimePoint);//<h>
```


</Error>


Below, we create our `tm` called `TimeContainer`, and use the `localtime_r()` function to populate it using data from our `time_t`, which we've called `TimeSinceEpoch`: 


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

int main() {
  using namespace std::chrono;
  time_point StartTime {
    system_clock::now()
  };
  std::time_t TimeSinceEpoch {
    system_clock::to_time_t(StartTime)
  };

  tm TimeContainer;
  localtime_s(&TimeContainer, &TimeSinceEpoch);

  std::cout << "The current time is "
    << TimeContainer.tm_hour << ":"
    << TimeContainer.tm_min;
}
```


```c++
//<o>
The current time is 23:32
```


<Aside>


### Creating a `time_t` from a `tm`


If we want to go in the opposite direction, the `std::mktime()` function can help us.  We pass it a pointer to a `tm` and it returns the equivalent `time_t`:


```c++
void HandleTime(std::tm* T) {
  std::time_t Time{std::mktime(T)};
  // ...
}
```


</Aside>


## Using `std::put_time()` and Format Strings


**Note:** C++20 introduced `std::format()`, which is a modern and more flexible alternative to `std::put_time()`.  If using `std::put_time()` causes issues or unexected output in your environment, don't worry too much about it.  Just proceed to the next lesson, where we'll  implement the same capability using `std::format()` instead.


Formatting a date and time to be displayed in a user-friendly way is a surprisingly complex task.  With some effort, we could use the various member variables of the `tm` struct to accomplish it, but there are easier ways.


In this section, we'll cover `std::put_time()`, which lets us output the content of `std::time_t` objects using a _**formatting string**_.  A formatting string is a string that contains special tokens that will be replaced by dynamic values, such as the contents of a variable.


To access `std::put_time()`, we need to `#include <iomanip>`.  We can then call `std::put_time()`, which accepts two arguments:

- A pointer to our time container
- The formatting string

The following shows this in action:


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

int main() {
  using namespace std::chrono;
  time_point StartTime {
    system_clock::now()
  };
  time_t TimeSinceEpoch {
    system_clock::to_time_t(StartTime)
  };

  tm TimeContainer;
  localtime_r(&TimeSinceEpoch, &TimeContainer);

  std::cout << std::put_time(//<h>
    &TimeContainer,//<h>
    "The current time is %T on %A"//<h>
  );//<h>
}
```


Running this code, we'd see a user-friendly time output:


```c++
//<o>
The current time is 17:08:01 on Wednesday
```


The `std::put_time()` function examines our format string and replaces tokens like `%T` and `%A` with dynamic content based on the values stored within the `TimeContainer`.


There are dozens of different tokens we can use to get the output we want.  We cover these tokens in more detail in the next lesson, covering string interpolation.  A full list of options is also available from most standard library references, such as [cppreference.com](https://en.cppreference.com/w/cpp/io/manip/put_time).


## Putting Everything Together


Let's put all these concepts together, to see a more complicated example of working with clocks, time points, durations, and thread sleeping:


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

void PrintTime(const time_t& Time) {
  tm TimeContainer;
  localtime_s(&TimeContainer, &Time);

  std::cout << std::put_time(
    &TimeContainer,
    "The current time is %T on %A\n");
}

int main() {
  using namespace std::chrono;
  time_point StartTime{system_clock::now()};
  PrintTime(system_clock::to_time_t(StartTime));

  std::this_thread::sleep_for(seconds(5));

  time_point EndTime{system_clock::now()};
  PrintTime(system_clock::to_time_t(EndTime));

  duration RunningTime{
    EndTime - StartTime};

  std::cout << "The running time was "
    << duration_cast<milliseconds>(RunningTime)
         .count()/1000.0 << " seconds";
}
```


Our output will be something like:


```c++
//<o>
The current time is 17:13:12 PM on Wednesday
The current time is 17:13:17 PM on Wednesday
The running time was 5.012 seconds
```


## Summary


In this lesson, we've explored the essential concepts of handling dates, times, and durations in C++ using the chrono library.  We also introduced other representations of time, including Unix timestamps stored in the `std::time_t` type, and the `tm` struct.


**Key Learnings:**

- Understanding and using `std::chrono::duration` for representing time intervals in various units.
- Implementing and manipulating time using the `chrono` library, including addition, subtraction, and comparison of durations.
- Utilizing different types of clocks in C++, namely `system_clock`, `steady_clock`, and `high_resolution_clock`, for various time measurement needs.
- Creating and manipulating `std::chrono::time_point` objects to represent specific points in time.
- Converting time points to and from `std::time_t` and using `tm` structures for a more readable time format.

<Preview>


### String Interpolation


In the upcoming lesson, we'll learn more about string interpolation in C++, focusing on the powerful `std::format()` and `std::print()` functions introduced in C++20 and C++23.


Building on our knowledge from this lesson, we'll see how these functions can be seamlessly integrated with the `chrono` library to format and display dates and times in a more user-friendly manner.


**Key Topics Include:**

- Introduction to `std::format()` and `std::print()` functions for advanced string formatting.
- Understanding format specifiers and how they can be used to customize the output.
- Practical examples demonstrating the use of `std::format()` and `std::print()` in real-world scenarios.
- Techniques for incorporating `chrono` library types with `std::format()` to output time and date information.

</Preview>

Added note on `std::put_time()` inconsistency

Added Error styling to the `localtime_r` on Windows section

3D art showing a sundial in a fantasy environment

Chrono library

chrono::duration

std::chrono

{CPP}Master times in C++, covering chrono types, std::time_t, the tm struct, and how they interact

{CPP}C++ Basics: Handling Dates, Times, and Durations

Using `std::put_time()` and Format Strings

Dates, Times and Durations

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Intro to C++ Programming