Free and Unrestricted Access

Introduction to C++

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

21,869 Reviews

623,291 Learners

Updated 1 Week Ago

C++SDL

Start From Fundamentals

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

We start from first principles, and build our knowledge step-by-step to create complete applications.

Understand Every Line of Code

No copying-and-pasting code in this course.

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

Use Professional Best Practices

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

This means the techniques we learn are usable in large, professional projects.

Focus on Transferrable Skills

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.

3D art showing a progammer setting up a development environment

Free, unlimited access

This course includes:

60 Lessons
Over 200 Quiz Questions
95% Positive Reviews
Regularly Updated
Help and FAQ

Not Ready Yet?

Subscribe to this course to return to it later, and get updates on future changes

Chapter 1
Types and Variables

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

Chapter 2
Functions, Conditionals and Loops

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.

Creating and Calling Functions

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

The Call Stack and Debugging Functions

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

3D art showing a branching path in a forest

Conditional Logic

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

3D art showing a plumber repairing leaky pipes

Switch Statements

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

Function `return` Statements

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

Implicit Conversions and Narrowing Casts

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

3D art showing two birds having an argument

Function Arguments and Parameters

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

Scope

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

Forward Declarations

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

Loops

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

The Modulus Operator (`%`)

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

Fizz Buzz

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

Chapter 3
Classes and Structs

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.

3D art showing a character looking into the distance

Abstraction and Classes

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

Encapsulation and Access Specifiers

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

Constructors and Destructors

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

Structs and Aggregate Initialization

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

Operator Overloading

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

3D art showing a fantasy pirate character

Structured Binding

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

Chapter 4
Inheritance

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

3D art showing a fantasy vampire character

Inheritance

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

Protected Class Members

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

3D art showing a female blacksmith character

Member Initializer Lists

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

Working with Inherited Members

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

Chapter 5
Memory, References and Pointers

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

References

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

Pointers

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

The `this` Pointer

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

Dangling Pointers and References

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

Chapter 6
Polymorphism

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

3D art showing a character using a compass

Function Overloading

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

3D art showing a fantasy character working in an office

Static Casting

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

Virtual Functions and Overrides

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

Downcasting

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

Chapter 7
The Preprocessor and the Linker

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.