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 this session, we'll explore how function calls in C++ create what's known as a "call stack" and how this knowledge is vital in navigating the debugging process.


We start with a simple program to illustrate these concepts, making them easy to grasp. You'll learn about the call stack, a core component of program execution, and how to visualize it as a series of stacked blocks, each representing a function call.


Then, we explore the practical aspect of debugging. You'll get hands-on experience with tools like Step Over, Step Into, and Step Out. Understanding these tools is key to managing the complexity of code, especially when dealing with multiple function calls.


By the end of this lesson, you'll have a solid foundation in understanding the call stack and how to navigate it using a debugger. So, let's get started!


</Excerpt>


## An Example Program


Let's create the following simple program to introduce the concept of the call stack.


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

int Health{150};

void TakeDamage(){
  cout << " - TakeDamage function starting\n";
  Health -= 50;
  cout << " - TakeDamage function complete\n";
}

int main(){
  cout << "Main function starting\n";
  TakeDamage();
  cout << "We are back in main\n";
  TakeDamage();
  cout << "Main function complete\n";
}
```


The result of running this program can be seen here:


```c++
//<o>
Main function starting
 - TakeDamage function starting
 - TakeDamage function complete
We are back in main
 - TakeDamage function starting
 - TakeDamage function complete
Main function complete
```


The following diagram illustrates the flow of this program through time.


<Img hasTransparency file="cs2.png" width="955" height="153" alt="A diagram showing the call stack over time" blurHash="LfOp.Jofxaof9Iayxtay~oayxtay" />


## What is the Call Stack?


Imagine running a program as building a tower, where each block is a function call. This tower is what we call the "call stack."


### The Foundation: `main` Function


Every C++ program starts with the `main` function - it's like the base of our tower. The program ends when `main` finishes, much like how a tower can't stand without its base.


### Adding Blocks: Function Calls


When `main` calls another function, like `TakeDamage()` in our example, think of it as pausing `main` to place a new block on top. This new block is `TakeDamage()`. Now, our tower has two blocks - `main` at the bottom, and `TakeDamage()` on top.


### A Growing Tower: The Stack


Each time a function calls another, we add another block to our tower. The function on top is the one currently running. When it finishes, we remove its block, and the function below resumes execution where it left off.


### Viewing the Call Stack in the Debugger


We first introduced the debugger in our previous chapter:


<LessonPromo url="intro-to-programming/debugger" title="Introduction to Debugging" description="Creating a tiny program using numbers and booleans, then adding some breakpoints so we can step through our code in a debugger." />


This lesson builds on that knowledge, showing how function calls and the call stack affect our debugging.


When debugging our program, most debuggers will include a user interface that shows us a snapshot of our call stack at the point our execution has paused.  In Visual Studio, it looks like this:


<Img file="callstack.png" width="445" height="249" alt="A screenshot of the call stack from the Visual Studio debugger" blurHash="L268BP-p-:Ri-;xuxuj@_3Rjt7t7" />


Here, we have paused execution by setting a breakpoint within our `TakeDamage()` function.  We see that in our call stack at that point, external code (ie, the operating system) is at the bottom of the stack.


The operating system invoked our `main` function, so its stack frame is on top of the external code.  And `main` invoked `TakeDamage()`, so its stack frame is on top of `main`.


<Ad />


## The Call Stack and the Debugger


When debugging our earlier code, we had only one level of depth - everything was in the `main` function. There, we saw how we could advance execution line by line in the debugger using _Step Over_


Likely, you noticed that many different options appear when we start debugging. Many of those are to allow us to navigate the call stack created by our functions.


The three we want to talk about here are the different ways we can progress our application when debugging - Step Over, Step Into, Step Out.


Almost all debuggers support these actions, but they may have slightly different names within the respective user interfaces.  In Visual Studio, these actions become available from the top menu when we're debugging a program:


<Img file="debugger-buttons.PNG" width="593" height="107" alt="A screenshot of the visual studio Step Over button" blurHash="L69jv200_3-;00_4D$IUIUtSV@aK" />


## Debugging Functions: Step Over


In our previous lesson, we saw that **Step Over** advances execution of our code, line by line.  But what if the line we're about to execute is a function call?


In that scenario, Step Over will run that function to completion behind the scenes.  We won't see the inner workings of that function - we'll just see its effects once it is done.


In our example, if we're in the `main` function, and Step Over a line that calls `TakeDamage()`, the call to `TakeDamage()` will complete entirely.  Once control shifts back to `main`, our debugger will pause execution again, and continue to let us step through `main`, line by line.


<Img hasTransparency file="stepOver.png" width="751" height="120" alt="Diagram illustrating the effect of step over" blurHash="LBSF;Mxu?aM|~qof-:WB%MRj9Fj]" />


This is particularly useful when you want to focus on the flow of the function we're currently debugging, without getting sidetracked by the inner workings of every function it calls.


## Debugging Functions: Step Into


When we're on a line of code that is about to call a function, we have the option to **Step Into** that function call.


Unlike **Step Over**, which skips over the details of a function call, **Step Into** takes you right into the heart of it. When you're on a line that's about to call a function, like when `main` is set to call `TakeDamage()`, using **Step Into** transports you directly to the first line of `TakeDamage()`.


<Img hasTransparency file="stepIn.png" width="751" height="120" alt="Diagram illustrating the effect of step in" blurHash="LCSPX_og%Ms:~qj[%Mof%MRj9Fj[" />


We could then move through the `TakeDamage()` function, line by line.


## Debugging Functions: Step Out


After using **Step Into** to delve into a function like `TakeDamage()`, you might decide that you've seen enough and want to resume following the main flow of your program in `main`. This is where **Step Out** comes into play.


When you activate **Step Out**, the debugger completes the rest of the current function - in this case, `TakeDamage()` - without pausing. It essentially fast-forwards to the end of the function. Once `TakeDamage()` is fully executed, the debugger takes you back to the calling function, resuming right after where the function call was made.


In our example, you'd be brought back to `main`, right after the point where `TakeDamage()` was called.


<Img hasTransparency file="stepOut.png" width="751" height="120" alt="Diagram illustrating the effect of step out" blurHash="L8SF;M-:?aD*~qxt?bM|_3M{9Fof" />


<Ad />


<Aside>


### Continue


As before, we still have the option to **Continue** when debugging our program.  Its behavior is not changed by function calls and it does not interact with the call stack explicitly.  **Continue** will simply proceed with execution until the next breakpoint is found, or the program ends.


</Aside>


Take some time to add a breakpoint to your code, and experiment with the debugger and how these options navigate around your code.


Establishing an understanding of the call stack concept in this simple program will greatly help us understand what is going on in bigger applications, and will be vital to help us debug them when things inevitably go wrong.


<Quiz title="Call Stack Debugging">


<Question>


When debugging, which action lets us enter a function that is about to be called?


<Answer>
Step Over
<Feedback>


The purpose of "Step Over" is to advance within the current stack frame without diving into the details of the functions it calls. Think about how this differs from the action that lets us actually enter a function call.


</Feedback>


</Answer>


<Answer>


Step Out


<Feedback>


"Step Out" has a specific use in the debugging process, but it's not the one that allows us to enter a new function. Consider what happens when you choose to "Step Out" of a function you're currently in.


</Feedback>


</Answer>


<Answer isCorrect>


Step Into


<Feedback>


You got it!

- _Step Into_ will allow us to enter a function that is about to be added to the call stack
- _Step Over_ will advance us within the current stack frame
- _Step Out_ will continue execution until our current function is off the call stack

</Feedback>


</Answer>


</Question>


</Quiz>


Up next, we'll see how we can use booleans to make our functions more powerful and dynamic


## Summary


In this lesson, we covered the main aspects of calling and debugging functions in C++.  The key points are:

- **The Call Stack**: Function calls create a call stack, with `main` as the base.  When functions end, they're removed from the stack.
- **Step Over**: Advancing through code line by line, bypassing the internal details of function calls.
- **Step Into**: Entering specific function calls to inspect each step.
- **Step Out**: Exiting a function and returning to the calling function in the stack.

These tools and concepts are crucial for effective debugging and understanding the flow of C++ programs.


<Preview>


### Conditional Logic


Next, we will explore conditional logic in programming:

- Exploring `if` and `else` statements to implement for decision-making in code.
- Using _**ternary statements**_ to quickly create branching logic
- Hands-on with Practical Examples: Applying conditional statements in various programming scenarios.

</Preview>

The Debugger

Call stack

Using the Debugger in Visual Studio

{CPP}Gain a thorough understanding of the C++ call stack and how to navigate it using a debugger

The Call Stack and Debugging Functions

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Intro to C++ Programming