Getting our machines set up for C++ development, and introducing the fundamental building blocks of programming - variables.

Getting our computer set up so we can create and build C++ programs. Then, creating our very first application

Setting up a C++ Development Environment

An introduction to the building blocks of our software - objects, and the variables that can be associated with them.

Objects, Variables and Types

Creating variables to store and update the data that describes our objects.  We also introduce comments, allowing us to describe our code in plain language.

Creating Variables

An introduction to the different types of numbers in C++, and how we can do basic math operations on them.

Numbers

An overview of the fundamental true or false data type, how we can create them, and how we can combine them.

Booleans - `true` and `false` values

Explore how C++ programs store and manage numbers in computer memory, including integer and floating-point types, memory allocation, and overflow handling.

Types and Literals

Creating a tiny program using numbers and booleans, then adding some breakpoints so we can step through our code in a debugger.

Introduction to Debugging

Types and Variables

Discover how we can package our code into reusable functions that we can easily call.  Then, learn how we can use conditionals and loops to control the flow of our program.

An introduction to functions - reusable blocks of code that we can use to break our application into smaller pieces.

Creating and Calling Functions

An introduction to how our function calls create a call stack, and how we can navigate it in a debugger.

The Call Stack and Debugging Functions

Use booleans and if statements to make our functions and programs more dynamic, choosing different execution paths.

Conditional Logic

Learn an alternative way to write conditionals, which is often used when we want to take different paths based on a specific value

Switch Statements

Allow our functions to communicate with their caller by returning values when they complete

Function `return` Statements

Going into more depth on what is happening when a variable is used as a different type

Implicit Conversions and Narrowing Casts

Making our functions more useful and dynamic by providing them with additional values to use in their execution

Function Arguments and Parameters

Learn more about how and when we can access variables, by understanding the importance of the scope in which they exist.

Scope

Understand what function prototypes are, and learn how we can use them to let us order our code any way we want.

Forward Declarations

Learn how we can use loops to iterate over a block of code, executing it as many times as needed.

Loops

Learn how we can use the modulus operator to get the remainder of integer division, and some common use cases.

The Modulus Operator (`%`)

Put everything we've learned in this chapter to the test by creating a C++ version of the Fizz Buzz game.

Fizz Buzz

Learn how the `&&` and `||` operators are optimized with short-circuit evaluation, only evaluating expressions when necessary

Short-circuit Evaluation

Functions, Conditionals and Loops

Classes and structs are the fundamental feature of object oriented programming.  In this chapter, we will see how we can set them up, and how we can use them to create the custom types our program needs.

Learn how to define, instantiate, and utilize classes, understanding how they form the backbone of object-oriented programming.

Abstraction and Classes

A guide to encapsulation, class invariants, and controlling data access with `public` and `private` specifiers.

Encapsulation and Access Specifiers

Learn about special functions we can add to our classes, control how our objects get created and destroyed.

Constructors and Destructors

Discover the role of structs, how they differ from classes, and how to initialize them without requiring a constructor.

Structs and Aggregate Initialization

This lesson introduces operator overloading, a fundamental concept to create more intuitive and readable code by customizing operators for user-defined types

Operator Overloading

This lesson introduces Structured Binding, a handy tool for unpacking simple data structures

Structured Binding

Classes and Structs

See how we can use inheritance to organise our classes into a hierarchy, unlocking a massive range of possibilities for building more complex software

In this lesson, we explore C++ inheritance, guiding you through creating and managing class hierarchies to streamline your code

Inheritance

Learn about `protected` class members in C++, including how and when to use them in your code, especially in the context of inheritance and class design

Protected Class Members

This lesson introduces Member Initializer Lists, focusing on their advantages for performance and readability, and how to use them effectively

Member Initializer Lists

This lesson provides an in-depth exploration of using inherited methods and variables in C++, covering constructor calls, variable modification, and function shadowing

Working with Inherited Members

An introduction to working with memory, and how we represent memory locations using references and pointers

This lesson introduces references, explaining how they work, their benefits, and their role in performance and data manipulation

References

This lesson provides a thorough introduction to pointers in C++, covering their definition, usage, and the distinction between pointers and references

Pointers

Learn about the `this` pointer in C++ programming, focusing on its application in identifying callers, chaining functions, and overloading operators.

The `this` Pointer

Learn about an important consideration when returning pointers and references from functions

Dangling Pointers and References

Memory, References and Pointers

An introduction to polymorphism - the key tool that let us build more complex programs whilst keeping our code simple.

This lesson provides an in-depth look at function overloading in C++, covering its importance, implementation, and best practices

Function Overloading

Explore the concept of static casting in C++, including examples and best practices for converting data types at compile time

Static Casting

This lesson provides an introduction to virtual functions and overrides, focusing on their role in enabling runtime polymorphism

Virtual Functions and Overrides

Get to grips with downcasting in C++, including static and dynamic casts. This lesson provides clear explanations and practical examples for beginners

Downcasting

Polymorphism

Go deeper on what is happening when we build our software.  Learn how we can use the preprocessor to automatically modify our source code before it is compiled, and how the linker connects our program together.

Explore the essential concepts of C++ preprocessing, from understanding directives to implementing macros

Preprocessor Definitions

Discover how the `#include` directive helps us include library features and split our project across multiple files.

The `#include` Directive

Explore how header files and linkers streamline C++ programming, learning to organize and link our code effectively

Header Files

The Preprocessor and the Linker

Discover additional methods and techniques to keep our data and code organised.

Learn the essentials of using namespaces to organize your code and handle large projects with ease

Namespaces

Learn about Enums and how they offer an efficient way to handle predefined values in your code

Enums

This lesson introduces the `using` keyword in C++, focusing on namespaces, enums, and type aliasing

The `using` Keyword

Namespaces and Enums

Learn how to store collections of objects, and take control of how memory is managed

Explore the fundamentals of dynamic arrays with an introduction to `std::vector`

Dynamic Arrays using `std::vector`

Learn how to manage dynamic memory using unique pointers and the concept of memory ownership

Memory Ownership and Smart Pointers

Explore advanced techniques for managing object copying and resource allocation

Copy Constructors and Operators

Learn the techniques and pitfalls of manual memory management in C++

Managing Memory Manually

Arrays and Dynamic Memory

Techniques to simplify our code, making it easier to understand and maintain

This lesson covers how we can ask the compiler to infer what types we are using through the `auto` keyword

Automatic Type Deduction using `auto`

Learn the intricacies of using `const` and how to apply it in different contexts

Constants and `const`-Correctness

This lesson provides an overview of effective commenting strategies, including Javadoc style commenting for automated documentation

Effective Comments and Javadoc

This lesson introduces the concept of Style Guides and ClangFormat, focusing on how to achieve consistency in our code

Style Guides and Automatic Code Formatting

An introduction to static analysis tools, and how they can help beginners learn faster and improve code quality

Static Analysis

Explore the fundamentals of attributes, including `[[nodiscard]]`, `[[likely]]`, and `[[deprecated]]`

Attributes

Clean Code

A collection of lessons covering a variety of topics worth learning as a beginner

This lesson covers the basics of using randomness, with practical applications

Random Number Generation

Learn the basics of the chrono library and discover how to effectively manage durations, clocks, and time points

Dates, Times and Durations

A detailed guide to string formatting using C++20's `std::format()`, and C++23's `std::print()`

String Interpolation

Learn how to overload the `<<` operator, so our custom types can stream information directly to the console using `std::cout`

Overloading the `<<` Operator

This lesson introduces system calls, and how to use them to clear the terminal

System Calls and Terminal Management

This lesson introduces the fundamentals of capturing user input, using `std::cin` and `std::getline()`

User Input in the Terminal

Unravel the fundamentals of bitwise operators and bit flags in this practical lesson

Bitwise Operators and Bit Flags

Odds and Ends

This course is designed for beginners. We'll take you from the fundamentals and lay a solid foundation for creating real-world programs and learning more advanced concepts.

Become a software engineer with C++.  Starting from the basics, we guide you step by step along the way

This course teaches the fundamentals of C++ while instilling habits used by real-world developers. You'll gain practical experience with concepts that are the foundation of all modern programming.

No previous programming experience is needed - we start from the basics.

Start your Journey

We explain every line of code we're using, so you understand exactly what is happening.

Understand Every Line of Code

Everything we create is organised and implemented using modern, professional practices.

Use Professional Best Practices

We don't just explain what we're doing, but also why. This builds transferrable skills, so you can take what you've learnt and apply them to your own projects.

Focus on Transferrable Skills

No paywalls, no ads - the course is completely free with unlimited access

Free and Unrestricted Access

We break complex concepts into manageable steps, making even advanced topics feel approachable.

Step-by-Step Learning

What You'll Learn

Comprehensive course covering advanced concepts, and how to use them on large-scale projects.

Professional C++

If you're already familiar with the basics of C++ and object oriented programming, you may want to skip to the advanced course.  It starts with a quick summary of everything we cover here.

Already Familiar with Programming?

Intro to C++ Programming

<Excerpt>


In the previous chapter, we discussed how we can approach programming by thinking about objects - things that exist within the world our program is trying to simulate.


For example, were we making a fantasy game, we might be simulating objects like monsters, weapons, and magical spells.


We saw how we have two fundamental tools to simulate an object:

- variables, that represent the current state of the object
- functions, that allow the object to perform actions

```c++
// Variable
int Health{150};

// Function
void TakeDamage(int Damage){
  Health -= Damage;
}
```


</Excerpt>


## Abstraction


Our game might have thousands of objects.  We don't want to define tens of thousands of variables and functions to manage this.


Instead, we want to write code that can apply to large sets of these objects.  For example, maybe 100 of our objects will be monsters that the player can fight.


All the monster objects in our game likely share a lot of similar characteristics - for example, they may all have `Health` variables, and they all have `TakeDamage()` functions.


So, rather than writing code for 100 individual monster objects, we write code that works for _**all**_ monsters, which they can then share.


This process of generalization, where we take specific objects and group them into more general categories is called **abstraction**


<Quiz title="Abstraction">


<Question>


What is Abstraction?


<Answer>


Abstraction is how we delete objects, freeing up the memory they are using.


<Feedback>


This answer confuses abstraction with another concept. Remember, abstraction is about simplifying complex realities by identifying categories of objects based on shared characteristics, not about memory management. 


</Feedback>


</Answer>


<Answer isCorrect>


Abstraction involves categorizing objects into more general types, where objects of the same type share some common characteristics.


<Feedback>


Correct! Abstraction is indeed about creating general categories for objects that share similar characteristics. This simplification allows us to manage and manipulate groups of objects more efficiently in programming.


</Feedback>


</Answer>


<Answer>


The process we use to create a new object


<Feedback>


This answer describes a different aspect of object-oriented programming. Recall that abstraction is more about the conceptual framework of grouping similar objects, rather than the specific process of creating individual objects.


</Feedback>


</Answer>


</Question>


</Quiz>


<Ad />


## Built-in Types


We already saw examples of abstraction in the built-in types we've been using.  For example, `int` is an abstraction.


C++ compilers didn't have to define code for every individual integer, like `3`, `42`, and `53,195`.  Rather, they created an abstract concept of what an integer is, and the things an integer can do.


All integer objects then share those capabilities - like the ability to be incremented using the `++` operator or be logged to the terminal using the `<<` operator.


The `int` data type is what provides that abstraction.  Similarly, `bool` provides an abstraction for true and false values, whilst `string` abstracts blocks of text.


## User-Defined Types


Just as C++ provides some built-in types that are useful to a wide range of programs:


```c++
int Level;
bool isAlive;
string Name;
```


So too does it give us the ability to create _**user-defined types**_.  These are types that we can set up to generalize the categories of objects that will exist in our specific project:


```c++
Monster Goblin;
Weapon IronSword;
Spell Fireball;
```


A _**class**_ is the main way we define a custom type.  To create a user-defined type, such as `Monster`, we would create a `class` like this:


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

class Monster {//<h>
public://<h>
  // Class code here//<h>
};//<h>

int main() {
  // We can now create Monsters
  Monster Goblin;//<h>
}
```


We describe the meaning of the `public:` line later in this chapter.  For now, let's just ensure it is included at the top of our classes.


Note that it's important that our class definition end with a semicolon.  Forgetting the semicolon here is a common mistake, and the error message that it generates isn't always clear:


```c++
class Monster {
public:

}; // Remember the semicolon//<h>
```


<Quiz title="Creating Classes">


<Question>


How can we define a class called `Weapon` in C++?


<Answer isCorrect>


```c++
//<qa>
class Weapon {
public:
};
```


<Feedback>


That's right! This is the correct syntax for defining a class in C++. The `class` keyword is followed by the class name


</Feedback>


</Answer>


<Answer>


```c++
//<qa>
class Weapon() {
public:
};
```


<Feedback>


This answer uses parentheses, which are not used in the class definition syntax in C++. Remember, the class name should be followed by curly braces, not parentheses.


</Feedback>


</Answer>


<Answer>


```c++
//<qa>
class Weapon (
public:
);
```


<Feedback>


In this answer, the use of parentheses is incorrect. The syntax for defining a class in C++ uses curly braces **`{}`** to enclose the class body.


</Feedback>


</Answer>


</Question>


</Quiz>


## Classes vs Objects


There is often some confusion at this point about what differentiates an _**object**_ from a _**class**_. This will become clear as we start creating classes and objects in future lessons, but let's discuss it briefly here.


The English definition of class is: _a category of things having some property or attribute in common_


It means the same thing in programming. A class defines an abstract category of things that are, in some way, similar.  The things within that category are objects.


Consider this example.


```c++
Monster Bonker;
Monster Basher;
```


Here, `Monster` is a _**class**_.  It is not a specific monster - it is an abstract idea of what it is to be a monster.  It includes a description of what variables and functions all monsters have.


A class also grants the ability to create new objects of that class.  Above, we're using that ability to create two specific monsters.  Bonker and Basher are both _**objects**_.


<Definition>


### Instances and Instantiating


Because classes are used to construct objects, people often conceptualize classes as _blueprints_ when explaining the concept.  The class is a blueprint for creating a specific type of object.  Many objects can be created from the same blueprint.


Creating an object from a class is sometimes referred to as _**instantiating**_ the class.  The objects created are sometimes called _**instances**_.


Above, we _**instantiate**_ the `Monster` class to create Bonker and Basher.


Bonker and Basher are _**instances**_ of the `Monster` class.


</Definition>


<Quiz title="Instantiating Classes">


<Question>


What is a Class?


<Answer isCorrect>


A category of objects, from which we can create new instances of that type of object.


<Feedback>


Correct! A class in programming is like a blueprint. It defines a category of objects, and we use it to create instances (objects) of that type.


</Feedback>


</Answer>


<Answer>


A collection of objects - for example, 100 Goblins stored in memory is a class.


<Feedback>


Remember, a class is a blueprint for objects, not the collection of those objects themselves. Think about what defines the properties and behaviors of individual objects.


</Feedback>


</Answer>


<Answer>


A specific entity that exists in our software, such as a monster with variables we can update and functions we can call.


<Feedback>


This description is more aligned with what an object is, not a class. An object is a specific instance created based on a class. Reflect on the difference between the general template (class) and individual instances (objects).


</Feedback>


</Answer>


</Question>


<Question>


What statement allows us to create a new Weapon object from this class?


```c++
class Weapon {
public:

}
```


<Answer>


`Weapon;`


<Feedback>


This answer misses a key aspect of instantiation. In C++, when we instantiate a class, we need to specify a variable name to create an object.


Think about how you would declare a variable of a basic type, like `int` or `string`, and apply that concept to this class.


</Feedback>


</Answer>


<Answer>


`Weapon { "IronSword" }`


<Feedback>


This syntax resembles an initialization but is not correct for instantiating a class in C++. Remember that to create an object, you need the class name followed by the object name.


The curly braces **`{}`** are not typically used this way when instantiating an object in basic scenarios.


</Feedback>


</Answer>


<Answer isCorrect>


`Weapon IronSword;`


<Feedback>


This is the correct way to instantiate an object in C++. You use the class name `Weapon` followed by the object name `IronSword`, ending with a semicolon.


This creates an object of the `Weapon` class named `IronSword`.


</Feedback>


</Answer>


</Question>


</Quiz>


<Ad />


## Class Members


To provide objects of our classes with the ability to store their state and perform actions, we need to define those variables and functions as part of our class.


Variables and functions that belong to a class are sometimes referred to as _**class members**_.


The syntax we use for class members is identical to what we're familiar with in the previous chapter.  We just place our variables and functions within the curly braces of a class definition.


For now, we should also ensure it is below the `public:` line within our class:


```c++
class Monster {
public:
  // a variable
  int Health { 150 };//<h>

  // a function
  void TakeDamage(int Damage) {//<h>
    Health -= Damage;//<h>
  }//<h>
};
```


<Definition>


### Class Member Terminology


There are lots of different terms people use for class members.


Variables within a class are sometimes referred to with names like _**data member**_, _**field,**_ or _**property**_


Similarly, a function that is associated with a class will sometimes be referred to using names like _**method**_ or _**member function**_


These all broadly relate to the same ideas, and the meaning should hopefully be clear from the context.


</Definition>


## The Member Access Operator


Once we've created an object from our class, we will want to access the variables and functions that are granted to our object by the class.


We do that through the member access operator, which is a simple period: `.`


For example, accessing the `Health` variable of a `Monster` object would look like this:


```c++
Monster Bonker;
Bonker.Health;//<h>
```


Calling a function would look like this:


```c++
Monster Bonker;
Bonker.TakeDamage();//<h>
```


Below, we show these concepts in a simple program:


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

class Monster {
public:
  int Health{150};

  void TakeDamage(int Damage){
    Health -= Damage;
  }
};

int main(){
  Monster Bonker;
  cout << "Bonker Health: " << Bonker.Health;//<h>
  Bonker.TakeDamage(25);//<h>
  cout << "\nBonker Health: " << Bonker.Health;//<h>
};
```


```c++
//<o>
Bonker Health: 150
Bonker Health: 125
```


We can use a class variable in the same way we use any other variable of that same type.  Above, `Bonker.Health` is an `int`, so we can use it like any other `int`.  For example, we can:

- Pass it as an argument to a function
- Copy its value to a new variable
- Use the `++` to increment it
- Use the `!=` to compare it to another number, generating a boolean result

<Quiz title="Class Member Access">


<Question>


Imagine we had the following code:


```c++
class Weapon {
public:
  int Damage { 50 };
};

Weapon IronSword;
```


What statement allows us to access the `Damage` integer of our object?


<Answer>


`Weapon.Damage;`


<Feedback>


This statement incorrectly uses the class name instead of an object name. Think about how you access the properties of an object you've created.


</Feedback>


</Answer>


<Answer isCorrect>


`IronSword.Damage;`


<Feedback>


You got it!  First, we specify the object the variable is a member of.  In this case, that is the `IronSword` object.


Next, we use the member access operator `.`


Then, we specify which member we want to access.  In this case, that is the variable called `Damage`


</Feedback>


</Answer>


<Answer>


`Damage.IronSword;`


<Feedback>


This syntax is reversed. In C++, the object name comes first, followed by the member access operator (`.`) and then the member name.


Consider the correct order for accessing a class member in an object.


</Feedback>


</Answer>


</Question>


</Quiz>


## A Note on Class Variables


A common point of confusion at this point is what exactly it means for all instances of a class to have the same set of variables.


Within our class definition, when we declare a variable in the way we've been demonstrating, we are stating that every object of our class will have a variable with that name, type, and initial value.


For example, the `Monster` class specifies that its instances will have integer variables called `Health` that start with a value of `100`.  However, until we instantiate the class to create an object, no such variable exists.


Once we do create some objects from our class - `Bonker` and `Basher` in the following example - they each get **their own copy** of that `Health` variable.


Each object's `Health` can then be updated independently, without affecting any other `Monster` instance:


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

class Monster {
public:
  int Health{100};
};

int main(){
  Monster Bonker;
  Monster Basher;
  cout << "Bonker's Initial Health: " << Bonker.Health;
  cout << "\nBasher's Initial Health: " << Basher.Health;

  Bonker.Health = 50;//<h>
  cout << "\nBonker's Health is now: " << Bonker.Health;
  cout << "\nBasher's Health is still: " << Basher.Health;
};
```


```c++
//<o>
Bonker's Initial Health: 100
Basher's Initial Health: 100
Bonker's Health is now: 50
Basher's Health is still: 100
```


## Class Function Prototypes


In the previous chapter on <InlineLessonPromo url="intro-to-programming/forward-declarations" title="Forward Declarations" description="Understand what function prototypes are, and learn how we can use them to let us order our code any way we want.">forward declarations</InlineLessonPromo> we introduced how a function can be declared and defined in different places in our code.


We can apply this same technique to class functions too, should we need to.  Within our class definition, we provide the prototype for our class function:


```c++
class Monster {
public:
  int Health { 150 };
  // Declaration
  void TakeDamage(int Damage);
};
```


We can then provide the definition elsewhere in our code.


The only difference is that, when we're defining a class function, we need to additionally provide the class name.  We do that by using the `ClassName::FunctionName` pattern.


For example, to define the `TakeDamage()` function for the `Monster` class, we would do this:


```c++
class Monster {
public:
  int Health { 150 };
  // Declaration
  void TakeDamage(int Damage);
};

// Definition
void Monster::TakeDamage(int Damage) {
  Health -= Damage;
}
```


This might seem quite weird but, for reasons we'll cover later, a lot of C++ code is written this way.  We'll stick with declaring and defining functions together in this course, but for now, just note that this separation is possible.


## Summary


The key points covered in this lesson were:

- Introduced the concept of **classes** as fundamental to object-oriented programming.
- Explained **abstraction** as the process of generalizing specific objects into broader categories, allowing for more efficient and manageable code.
- Discussed **built-in types** in C++ like `int`, `bool`, and `string`, showcasing them as examples of abstraction.
- Covered the creation of **user-defined types** through classes, enabling the definition of custom objects specific to a project's needs.
- Clarified the difference between a **class** and an **object**, with a class being an abstract category and an object being an instance of that class.
- Introduced the concept of **instantiating** a class to create objects, and the use of the **member access operator** (**`.`**) to interact with an object's variables and functions.
- Demonstrated how to define **class members**, including both variables and functions.
- Provided insights into **class function prototypes**, showing how functions can be declared within a class and defined elsewhere.

<Preview>


### Access Modifiers


In the upcoming lesson, we'll explore **access modifiers**, which control the visibility and accessibility of class members.

- We'll explore the **`public:`** modifier, as seen in this lesson, and introduce other modifiers
- We'll see how **public members** can be accessed from anywhere, while **private members** are only accessible within the class itself.
- We'll see how this lets us achieve _**encapsulation**_ - an important goal to keep complex projects manageable and pleasant to work on.

</Preview>

Merged and rewrote "What is a Class?" and "Creating Classes" lessons

Minor style improvements and rewrote "A Note on Class Variables" section

Added note on semicolons after class definitions

3D art showing a character looking into the distance

Classes (I) - C++ Tutorials

Class (computer programming)

C++ Classes and Objects

Classes

{CPP}Explore how classes and abstraction form the core of C++ programming.

Abstraction and Classes

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Intro to C++ Programming