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>


When dealing with excessively verbose code, C++ provides a few options for us to reduce the noise.  Typically, these options have the `using` syntax.  We'll explore the four main uses for it in this lesson:

- Reducing the amount of code we need to write when working with namespaces
- Reducing the amount of code we need to write when working with enums
- Changing the types our program uses based on a preprocessor definition
- Giving complex types shorter or more meaningful names

</Excerpt>


## Accessing Namespace Members


Starting from the very first lesson, we've had a line of code in our files that we've left unexplained thus far:


```c++
using namespace std;
```


Predictably, this line is related to namespaces.


The effect of this `using` declaration was an instruction that asks the compiler: "if an identifier we use is not found, try searching for it in the `std` namespace".


This `using` statement has been necessary every time we used `cout` and `string`. This is because the standard library functionality, including these identifiers, is in the `std` namespace:


```c++
#include <iostream>

int main() {
  std::string MyString{"Hello"};//<h>
  std::cout << MyString;//<h>
}
```


By adding a `using namespace std` declaration, we have the option of removing the `std::` prefix:


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

int main() {
  string MyString{"Hello"};//<h>
  cout << MyString;//<h>
}
```


We can use `using namespace` declarations with any namespace - not just `std`:


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

using namespace Maths;//<h>
using namespace std;

int main() {
  // equivalent to std::cout << Maths::Pi
  cout << Pi;//<h>
}
```


<Quiz title="Using Namespaces">


<Question>


What statement can we add below to make our call to `Square()` work?


```c++
namespace Utilities {
  void Square() {};
};

// ?//<h>

Square();
```


<Answer isCorrect>


`using namespace Utilities;`


<Feedback>


Correct! This statement allows you to use `Square()` without specifying the `Utilities` namespace, simplifying your code


</Feedback>


</Answer>


<Answer>


`#include <Utilities>`


<Feedback>


This isn't quite right. Remember, `#include` is used for including files, not for bringing a namespace into scope.


</Feedback>


</Answer>


<Answer>


`import Utilities;`


<Feedback>


Not quite. In C++, `import` is not used for namespaces. Think about how you can directly use elements from a namespace.


</Feedback>


</Answer>


</Question>


</Quiz>


<Ad />


## Restricting `using` Declarations to Specific Identifiers


Rather than having a `using` statement that covers the entire `std` namespace, we can also restrict it just to specific identifiers.


For example, to use it with just `std::cout` and `std::string`, we could write this:


```c++
#include <iostream>

using std::cout, std::string;//<h>

int main() {
  string MyString{"Hello World"};
  cout << MyString;
}
```


```c++
//<o>
Hello World
```


## Should I use `using namespace` Statements?


Probably not. Namespaces exist to help us organize code - a `using namespace` declaration effectively subverts that organization.


Remember too how `#include` directives work - if we have a `using namespace` declaration that is scoped to an entire file, that would also affect any file that includes it.


This can cause things to get out of hand quite quickly so, if `using namespace` declarations are going to be adopted, be particularly cautious when using them on files that are likely to be included in other files.


The Unreal coding standard asks for `using` declarations to never be used in the global scope.  We talk about non-global `using` statements later in this lesson:


<Quote author="Unreal Engine Coding Standard" url="https://docs.unrealengine.com/4.27/en-US/ProductionPipelines/DevelopmentSetup/CodingStandard/">


Do not put using declarations in the global scope, even in a .cpp file. It's okay to put using declarations within another namespace, or within a function body.


</Quote>


And the Google C++ standard asks that `using` declarations never be used, anywhere:


<Quote author="Google Style Guide" url="[https://google.github.io/styleguide/cppguide.html#Namespaces](https://google.github.io/styleguide/cppguide.html#Namespaces)">


Do not use using-directives (e.g., `using namespace foo`).


</Quote>


If we want to use `using` statements, there are two ways we can get the benefits whilst reducing many of the drawbacks.

- Restrict them to the specific identifiers we need - eg `using std::string`.
- Reduce the scope of the `using` statement, which we cover in the next section

<Ad />


<Aside>


### Literals and `using` Statements


In an optional lesson in the first chapter of the course, we introduced <InlineLessonPromo url="intro-to-programming/types-literals" title="Types and Literals" description="Explore how C++ programs store and manage numbers in computer memory, including integer and floating-point types, memory allocation, and overflow handling.">`std::string` literals</InlineLessonPromo>, which use an `s` suffix to distinguish themselves from `char*` literals:


```c++
#include <string>

using namespace std;

int main() {
  // A std::string literal
  "Hello"s;
  
  // A char* literal
  "World";
}
```


Literals that are part of the standard library (as opposed to built into the core language) require appropriate `using` statements to be in effect before the compiler can recognize the syntax.  Previously, our `using namespace std;` was taking care of that for us but, if we remove that statement as recommended, our literals will stop working.


To solve this, the standard library (and most libraries that provide literals) organize things such that those namespaces are available that contain **only** those literals.  This means we can easily access those literals using less heavy-handed `using` statements.


In the standard library's case, we can access all the literals it provides by `using` the `std::literals` namespace.  Or, if we only need `std::string` literals, we can use the even lighter `std::string_literals` namespace:


```c++
#include <string>

using namespace std;//<d>
using namespace std::literals;//<h>

// Alternatively:
using namespace std::string_literals;//<h>

int main() {
  // A std::string literal
  "Hello"s;
  
  // A char* literal
  "World";
}
```


</Aside>


## Scoped `using` Declarations


All of the `using` declarations we cover in this lesson follow the normal block scoping rules of other statements.  A `using` declaration outside of any block has a "global" scope and will apply to the entire file.


This can be problematic, especially if that file is then added to further files, via the `#include` directive.


As an alternative to global `using` declarations, we can place them inside blocks - usually function bodies or other namespaces. This will limit their effect to just the scope of that block.


```c++
#include <iostream>

void Hello() {
  // This using statement's effects are
  // limited to just this function block
  using namespace std;//<h>
  cout << "Hello ";
}

void World() {
  // Error - there are no using
  // statements in effect in this scope
  cout << "World";  //<e>
}

int main() {
  Hello();
  World();
}
```


```c++
//<o>
error C2065: 'cout': undeclared identifier
```


## Accessing Enum Members (C++20)


In some files, we may want to use the same enum repeatedly, and the constant qualification of `MyEnumName::` would make our code excessively verbose.


We can solve this problem in the same we we tacked the equivalent issue with namespaces - by adding a `using` statement - specifically a `using enum` statement:


This can take our code from something like this:


```c++
enum class Faction { Human, Elf, Undead };

Faction MyFaction { Faction::Human };
```


To this:


```c++
enum class Faction { Human, Elf, Undead };

using enum Faction;//<h>

Faction MyFaction { Human };//<h>
```


Note, `using enum` is a relatively recent addition to the language, included as part of the C++20 spec.  In projects that use older compilers, it will not be available.


<Quiz title="Using Enums">


<Question>


What statement can we add below that would make our `Character` declaration valid?


```c++
enum class Hostility { Friendly, Neutral, Hostile };

// ?//<h>

class Character {
  Hostility Hostility { Friendly };
};
```


<Answer>


`using Hostility;`


<Feedback>


This answer is close, but not quite correct. Consider the specific C++ syntax for using elements from an enum class.


</Feedback>


</Answer>


<Answer isCorrect>


`using enum Hostility;`


<Feedback>


Exactly right! This statement allows you to use the members of `Hostility` without qualifying them with the enum class name


</Feedback>


</Answer>


<Answer>


`using namespace Hostility;`


<Feedback>


This isn't correct. `Hostility` is an enum class, not a namespace. There's a different `using` statement for enum classes.


</Feedback>


</Answer>


</Question>


</Quiz>


## Type Aliases with `using`


The final scenario where we want to demonstrate a `using` statement is for _**type aliasing**_.


This allows us to create a pseudonym for a type we want to use in our code:


```c++
using integer = int;//<h>

int main() {
  integer MyNumber{42};
}
```


There are two main uses for this.


### Switching Types at Compile Time


The first use case is to change what types we use based on a preprocessor definition.


For example, perhaps we want the specific type of integer we're using to be different between platforms.


Rather than scattering that logic throughout our code, we could keep it in one place.  


Below, we're using `int64_t` and `int32_t`, which work like the `int` type we've been using so far.  The only difference is that `int64_t` and `int32_t` are _**fixed-width integers**_.


That is, they specify exactly how many bits they use, rather than letting the platform decide:


```c++
#pragma once
#include <cstdint>

#ifdef PLATFORM_64BIT
  using integer = std::int64_t;
#else
  using integer = std::int32_t;
#endif
```


We then `#include` this file in all our other files, and use our new `integer` alias like any other type:


```c++
#include "types.h"

int main() {
  integer MyNumber{42};
}
```


### Aliasing Complex Types


The second use case for type aliases with the `using` statement is to give complex types shorter, or more meaningful names.


This is of limited use for now when we're dealing with simple types like `int` and `string` but, in C++, types can get fairly complex.


In the future, we'll see types like the one used by this `Inventory` variable:


```c++
std::unordered_map<
  Enums::ItemType, std::vector<Item&>
> Inventory;
```


Scattering a type like this through our function prototypes in a class declaration, for example, would get very messy.   So, we can use a `using` statement to create a simpler alias:


```c++
using Items = std::unordered_map<//<h>
  Enums::ItemType, std::vector<Item&>>;//<h>

class Character {
public:
  void SetInventory(Items Inventory) {//<h>
    mInventory = Inventory;
  }
  Items GetInventory() { return mInventory; }//<h>
private:
  Items mInventory;//<h>
};
```


<Aside>


### Type Aliases using `typedef`


There is another way to create type aliases, which uses the `typedef` syntax:


```c++
typedef int integer;//<h>

int main() {
  integer MyNumber;//<h>
}
```


The `typedef` syntax was inherited from the C language but is still commonly used.  We tend to stick with `using`, as it is compatible with templates, an advanced C++ feature we'll introduce in the next course.


</Aside>


## Summary


This lesson explores the use of `using` directives, exploring their applications in reducing verbosity, managing namespaces, and simplifying code through type aliasing


**Key Learnings:**

- The `using namespace` statement allows for shorter code by omitting the namespace prefix, particularly with the standard (`std`) namespace.
- Scoped `using` declarations can be confined to specific blocks like function bodies, reducing their global impact.
- The `using enum` statement simplifies enum usage by eliminating the need for enum class qualification.
- Type aliasing with `using` enables switching types at compile time and giving complex types more meaningful names.
- Caution around the `using namespace` statement is recommended, particularly in the global scope.

<Preview>


### Arrays


In our next lesson, we will introduce _**arrays**_ using `std::vector`.  The key topics we'll cover include:

- **Introduction to Arrays**: Understanding arrays as a fundamental concept in programming, where they serve as a way to store collections of items (like numbers, objects, etc.) in an ordered manner
- **Introduction to** **`std::vector`**: Introducing `std::vector` as an implementation of a dynamic array, and the difference between dynamic and static arrays.
- **Creating and Initializing a** **`std::vector`**: Learn how to declare `std::vector`, initialize it with values, and understand its dynamic nature.
- **Accessing Elements**: Methods to access and modify elements in a `std::vector`, including using the subscript operator.
- **Iterating over** **`std::vector`**: How to iterate through `std::vector` using various methods, including range-based for loops.
- **Practical Examples and Applications**: Real-world scenarios and code examples to solidify the understanding of `std::vector`.

</Preview>

Reorganized course to move memory management lessons later

Added "Literals and `using` Statements" section

Namespace Using-directives

Using-enum-declaration

Type Alias

{CPP}Understand "using" directives in C++, covering namespaces, enums, and type aliasing

{CPP}Master the C++ "using" Keyword

Restricting `using` Declarations to Specific Identifiers

Should I use `using namespace` Statements?

The `using` Keyword

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Intro to C++ Programming

The using Keyword

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

The `using` Keyword