Unlock the full power of C++, a timeless language at the heart of modern software development.
C++ continues to be a cornerstone in the programming world, even with the emergence of many newer languages. Mastering C++ not only sharpens your programming logic but also makes it easier to transition into today’s most in-demand languages and frameworks.

The Programming in C++ LearningKit is designed to help learners grasp both the functional and object-oriented programming paradigms, and understand when to apply each based on real-world scenarios.

Throughout the course, you will:

• Gain a solid understanding of C++ fundamentals
• Explore the latest features of C++20
• Learn to write clean, efficient, and portable code
• Strengthen your ability to debug and solve programming errors
• Practice extensively with hands-on coding challenges

This LearningKit brings together all essential C++ concepts and modern updates in one cohesive learning experience. It is structured to equip you with the knowledge and confidence to write professional-grade code that meets today’s industry standards.

Perfect for beginners and intermediate programmers alike, this course will set you up for success in systems programming, game development, embedded systems, and beyond.

This LearningKit with more than 56 hours of learning is divided into three tracks:

Course content

TRACK 1: GETTING STARTED WITH C++

In this track, the focus will be on the fundamental features of the C++ programming language.
Courses (20 hours +):

Fundamentals of C++: Getting Started

Course: 1 Hour, 30 Minutes

• Course Overview
• C++ Introduction
• Principles of C++ Code Execution
• C++ Code Principles
• C++'s Compilation Process
• C and C++ Differences
• Exploring Features of C++ and Its Compilers
• Setting up the G++ Compiler
• Executing C++ on Windows
• Setting up C++ on Mac
• Running C++ Code with a Build
• Printing Text Using C++
• Course Summary

Fundamentals of C++: Using Variables & Datatypes

Course: 1 Hour, 38 Minutes

• Course Overview
• Introducing C++ Variables
• Exploring Numeric Data Types
• Using Integral, Character, and Floating-point Types
• Creating Boolean Variables in C++
• Performing Logical and Arithmetic Operations
• Creating C-style Strings
• Creating C++-style Strings
• Modifying Strings
• Using Member Functions with Strings
• Indexing into Strings
• Using Operators with Strings
• Course Summary

Fundamentals of C++: Using the auto Keyword, Enums, and I/O Streams

Course: 55 Minutes

• Course Overview
• Using the auto Keyword
• Exploring Enumerated Types
• Accepting Single-word Input
• Experimenting with Accepting Input
• Exploring Finer Points of Accepting Input
• Formatting Data Using Utility Functions
• Course Summary

Control Structures in C++: Using Conditional Control Structures

Course: 1 Hour, 38 Minutes

• Course Overview
• Understanding Control Structures
• Creating if-blocks and if-else-if Ladders
• Using Overloaded Relational Operators
• Introducing Vectors
• Creating Iterators on Vectors
• Creating Variables in an if-block Scope
• Using Logical Operators
• Creating Switch Statements
• Creating Variables in the Scope of Switch Statements
• Creating Cases Based on Strings in Switch Statements
• Exploring the Finer Points of Switch Statements
• Creating Switch Statements on Strings
• Course Summary

Control Structures in C++: Range-based for Loops

Course: 1 Hour, 37 Minutes

• Course Overview
• Introducing Arrays and For Loops
• Using the Break and Continue Keywords
• Iterating over Multidimensional Arrays
• Understanding the STL
• Accessing Out-of-bound Elements of a Vector
• Searching in a Vector Using Templates
• Using the cend(), rend(), and crend() Functions
• Debugging C++ Code
• Configuring the Debugging of Code
• Using Debuggers to Play the Execution of Code
• Using String References
• Creating Range-based For Loops
• Course Summary

Pointers and References in C++: Getting Started with Pointers

Course: 58 Minutes

• Course Overview
• Introducing C++ Pointers
• NULL and nullptr Differences
• Creating Pointers in C++
• Creating C-style Strings
• Using Null Pointers
• Creating Pointers on Objects
• Creating Pointers to Vectors and Maps
• Course Summary

Pointers and References in C++: Allocating Memory with New & Delete Operators

Course: 1 Hour, 25 Minutes

• Course Overview
• Understanding the Use of Pointers
• Allocating Memory in C++
• Allocating Memory Using the new Keyword
• Understanding Finer Points of New and Delete
• Creating Strings and Vectors on the Heap
• Allocating Memory for Arrays on the Heap
• Exploring Finer Points of Array New and Delete
• Const Pointers versus Pointers to Consts
• Using Constant Variables and Pointers
• Creating Pointers to Constants
• Creating Constant Pointers
• Course Summary

Pointers and References in C++: Using Smart Pointers in Modern C++

Course: 1 Hour, 39 Minutes

• Course Overview
• Introduction to Smart Pointers
• Types of Smart Pointers
• Introducing Unique Pointers
• Exploring Unique Pointers
• Creating Shared Pointers
• Exploring Shared Pointers
• Exploring Finer Points of Shared Pointers
• Creating Weak Pointers
• Exploring Finer Points of Weak Pointers
• Exploring Invalid Weak Pointers
• Understanding the Use Case of Weak Pointers
• Course Summary

Pointers and References in C++: Working with References

Course: 46 Minutes

• Course Overview
• Introduction to References
• Creating References
• Referencing Different Objects
• Modifying Data Using References
• Creating Constant References
• Casting Variables to Be Constant
• Course Summary

Functions in C++: Using Functions & Parameter Passing

Course: 1 Hour, 32 Minutes

• Course Overview
• Introducing C++ Functions
• Declaring and Defining Functions
• Exploring Pass-by-value Data Types
• Understanding That Strings Are Passed by Value
• Exploring Pointers Pass-by-value Semantics
• Understanding How Pointers Are Passed by Value
• Understanding Pass-by-reference
• Exploring Pass-by-reference
• Passing Vectors and Strings Using References
• Passing in Integers as References
• Course Summary

Functions in C++: Using Default Arguments & Function Overloading

Course: 57 Minutes

• Course Overview
• Using Default Arguments
• Returning Pointers and References
• Using the auto Keyword
• Overloading Functions
• Exploring the Nuances of Overloading Functions
• Creating Header Files
• Course Summary

Assessment:
Final Exam: Getting Started in C++

TRACK 2: OBJECT-ORIENTED CONCEPTS IN C++

In this track, the focus will be on core programming in C++, where the learners will recognize the significance of object-oriented programming.
Courses (23 hours +)

OOP in C++: Getting Started with Object-oriented Programming

Course: 1 Hour, 25 Minutes

• Course Overview
• Object-oriented Programming (OOP)
• The Structure of Object-oriented Programming (OOP)
• Member Variables and Functions
• Creating Objects of a Class
• Defining Getter and Setter Functions
• Creating Constructors and Instantiating Objects
• Utilizing the Private Access Modifier
• Creating a Custom Header File
• Working with Custom Header Files in Code
• Discerning Common Errors When Using Header Files
• Course Summary

OOP in C++: Instantiating Objects Using Constructors

Course: 50 Minutes

• Course Overview
• Adding Default Arguments to Constructors
• Initializing Variables Using Initialization Lists
• Distinguishing the Nuances of Initialization Lists
• Execute Constructor Chaining
• Implementing the explicit Keyword
• Creating Structs in C++
• Course Summary

OOP in C++: Using the this Pointer & const Members

Course: 1 Hour, 5 Minutes

• Course Overview
• Using the this Pointer
• Chaining Method Invocations Using the this Pointer
• Creating const Objects and const Member Functions
• Identifying Common const Method Errors
• Using const Pointers and References
• Overloading Functions as const and Non-const
• Returning const and Non-const Values from Functions
• Using the const_cast and mutable Keywords
• Course Summary

OOP in C++: Using Static Members & Destructors

Course: 56 Minutes

• Course Overview
• Creating Pre-C++17 Static Variables
• Creating C++17 Static Variables
• Accessing Static Variables through Classes
• Defining and Invoking Static Functions
• Defining and Using Destructors
• Implementing Constructors and Destructors
• Instantiating and Deallocating a Pointer
• Course Summary

OOP in C++: Copy Constructors, Nested Classes, & Namespaces

Course: 1 Hour, 43 Minutes

• Course Overview
• Creating Copies Using a Copy Constructor
• Implementing Copy Constructors
• Using Pass-by-value and Reference with Objects
• Creating Required Copy Constructors
• Identifying Default Copy Constructor Errors
• Implementing Copy Constructors for Object Pointers
• Creating Friend Functions and Classes
• Creating Nested Classes
• Implementing Namespaces
• Storing Functions and Classes in Namespaces
• Creating and Referencing Namespaces
• Course Summary

C++ Inheritance & Polymorphism: Using Inheritance for is-a Relationships

Course: 1 Hour, 31 Minutes

• Course Overview
• Inheritance
• Inheritance and Composition
• Using Public Inheritance
• Using Members of Classes in Inheritance Hierarchies
• Accessing Members of Base Classes from Child Classes
• Using the 'protected' Access Modifier
• Access Modifiers
• Access Modifiers with Inheritance
• Using the Base Class Access Specifier
• Using 'protected' as the Base Class Access Specifier
• Using Private Inheritance
• Bypassing Access Modifiers Using 'using'
• Course Summary

C++ Inheritance & Polymorphism: Constructors, Destructors, & Inheritance

Course: 1 Hour, 24 Minutes

• Course Overview
• Using Constructors in Inheritance Hierarchies
• Using Base Class Constructors in Child Classes
• Accessing Base Class Fields from the Child Class
• Using Base Class Constructors in Derived Classes
• Using Copy Constructors in Inheritance
• Using Destructors in Inheritance
• Setting up an Inheritance Hierarchy for Polymorphism
• Creating Pointers with Inheritance
• Creating References with Inheritance
• Course Summary

C++ Inheritance & Polymorphism: Understanding & Using Polymorphism

Course: 2 Hours, 4 Minutes

• Course Overview
• Understanding Name Hiding
• Exploring Finer Points of Name Hiding
• Understanding How Static Binding Can Be Dangerous
• Polymorphism
• Mechanics of Polymorphism
• Introducing the 'virtual' Keyword
• Exploring Runtime Polymorphism
• Using Runtime Polymorphism with References
• Viewing Resources Used in Dynamic Method Dispatch
• Exploring Problems Related to Runtime Polymorphism
• Understanding Covariance
• Understanding the 'override' Specification
• Using the 'final' Keyword
• Course Summary

C++ Inheritance & Polymorphism: Pure Virtual Functions & Abstract Classes

Course: 1 Hour, 22 Minutes

• Course Overview
• Using Virtual Destructors
• Understanding Object Slicing
• Exploring Default Arguments to Virtual Functions
• Using Virtual Methods in Constructors & Destructors
• Exploring the '::' Operator
• Using Pure Virtual Functions
• Exploring Abstract Classes
• Using Interfaces
• Course Summary

C++ Inheritance & Polymorphism: Multiple Inheritance & the Diamond Hierarchy

Course: 1 Hour, 22 Minutes

• Course Overview
• Multiple Inheritance and Diamond Hierarchy Overview
• Understanding Multiple Inheritance
• Implementing Virtual Methods in Multiple Inheritance
• Creating a Diamond Inheritance Hierarchy
• Using C-style Casts in C++
• Performing Static Casts
• Casting Objects
• Performing Dynamic Casts
• Exploring Errors Related to Dynamic Casts
• Course Summary

C++: Getting Started with Operator Overloading

Course: 1 Hour, 23 Minutes

• Course Overview
• Operator Overloading in C++
• Creating Classes in C++s
• Overloading Operators
• Using Code to Overload Operators
• Using Overloaded Operators as Member Functions
• Using Non-member Functions to Overload Operators
• Using Friend Functions with Operator Overloading
• Overloading Operators with Primitive Right Operands
• Using Best Practices of Operator Overloading
• Overloading Operators with Primitive Left Operands
• Course Summary

C++: Overloading Arithmetic & Relational Operators

Course: 1 Hour, 46 Minutes

• Course Overview
• Using std::rel_ops
• Invoking Operators from Other Operators
• Generating Operator Overloads using std::rel_ops
• Overloading the + Operator
• Using the Overloaded + Operator
• Identifying Requirements for + Operator Overloads
• Overloading the += Operator
• Using the Overloaded += Operator
• Identifying Requirements for += Operator Overloads
• Overloading the Pre and Post Increment Operators
• Using the Overloaded ++ Operator
• Course Summary

C++: Stream Operators, Assignment Operators, & Copy-and-Swap

Course: 1 Hour, 25 Minutes

• Course Overview
• Using Insertion and Extraction Operators
• Using the << and >> Operators as Functions
• Overloading Insertion and Extraction Operators
• Using the Copy Assignment Operator
• Implementing the Copy Assignment Operator
• Comparing Copy Constructor to Copy Assignment
• Exploring Default Assignment Operator Issues
• Overloading the Copy Assignment Operator
• Using the Copy-Swap Idiom
• Creating Copy Assignment Operations with Copy-Swap
• Course Summary

C++: Using Function Templates

Course: 1 Hour, 47 Minutes

• Course Overview
• Function and Class Templates
• Defining the Use Case of Function Templates
• Recognizing the Finer Points of Function Templates
• Specifying Types for Templates
• Defining Templated Functions in Header Files
• Using Templated Functions in .cpp Files
• Using Function Templates with Custom Types
• Demonstrating Issues of Pointers with Templates
• Defining Template Specializations
• Using Template Specializations
• Overloading Templated Functions
• Overloading Templated Functions with Pointer Types
• Course Summary

C++: Function Templates with Multiple Parameters & Non-type Parameters

Course: 40 Minutes

• Course Overview
• Using Multi-value Function Templates
• Specifying Function Return Types through Templates
• Using decl_type
• Using Default Values in Template Parameters
• Using Non-type Template Parameters
• Course Summary

C++: Using Class Templates

Course: 1 Hour, 52 Minutes

• Course Overview
• Using Class Template Parameters
• Creating Classes with Template Parameters
• Using the Braced Initialization List Constructor
• Automatically Deducing Class Template Parameters
• Using Functional Notation for Initializing Variables
• Using Non-type Template Parameters with Classes
• Demonstrating Features of Non-type Parameters
• Specializing Class Templates
• Using Specialized Templates
• Using Partial Specializations
• Performing Partial Specializations
• Using static_assert
• Defining Friend Functions to Templated Classes
• Course Summary

C++: Using the Move Constructor & Move Assignment Operator

Course: 1 Hour, 23 Minutes

• Course Overview
• Contrasting L-Values and R-Values
• Using L-Value and R-Value References
• Implementing the Rule of
• Illustrating the Need for R-value References
• Illustrating the Advantages of Move Constructors
• Using Move Assignment Operators
• Outlining Features of the Move Assignment Operator
• The RAII Paradigm
• Using RAII and the Rule of
• Course Summary

TRACK 3: ADVANCED CONCEPTS IN C++

In this track, the focus will be on the exploration of advanced C++ topics like File Handling, Data Structures, First-class functions, Templates, C++ Lambdas, Graphics, and the development of a simple gaming application.
Courses (12 hours +)

File Handling in C++: Working with File Streams

Course: 58 Minutes

• Course Overview
• File Handling in C++
• Reading Integer and Float Data from a File
• Using the getline() Function
• Reading Structured Data
• Using the open() and close() Functions
• Writing Out Data
• Writing Out Structured Data
• Course Summary

File Handling in C++: Performing Advanced File Stream Operations

Course: 1 Hour, 55 Minutes

• Course Overview
• Writing Out Custom Objects
• Reading in Custom Objects
• Reviewing Operations with Input Streams
• Using get() and getline()
• Using seekg()
• Using put(), read(), and write()
• Understanding the Write and Append Modes
• Using the Ate Mode
• Writing Out Data Using Binary Mode
• Write Out and Read in Binary Data
• Reviewing Stream State Bits
• Using the Filesystem Library
• Performing Operations on Files
• Course Summary

Exception Handling in C++

Course: 1 Hour, 48 Minutes

• Course Overview
• Techniques for Propagating Errors
• How Exceptions Are Thrown and Handled
• Throwing and Handling Exceptions
• Defining Multiple Catch Blocks
• Handling Exceptions Using the try-catch Block
• Throwing Exceptions Using Exception Classes
• Creating and Using Custom Exception Classes
• Using Custom Exceptions and Catch Blocks
• Catching Exceptions by Reference
• Violating the noexcept Keyword
• Cascading Errors up the Stack Trace
• Using the Function-try-block
• Course Summary

C++: Working with Sequence Containers

Course: 1 Hour, 26 Minutes

• Course Overview
• Associative and Sequence Containers
• Sequence Container Types
• Creating and Iterating Arrays
• Using Vectors
• Inserting, Modifying, and Removing Vector Elements
• Creating Forward Lists
• Generating Lists
• Queue, Stack, and Priority Queue Container Adapters
• Making Deques
• Creating and Using Container Adapters
• Course Summary

C++: Working with Associative Containers & Algorithms

Course: 1 Hour, 22 Minutes

• Course Overview
• Associative Containers
• Making and Using Regular Sets
• Using Unordered Sets and Multisets
• Creating and Iterating Maps
• Utilizing Unordered Maps
• Creating Multimaps
• Ordering Containers
• Using Algorithms on Containers
• Performing Advanced Algorithms and Transformations
• Course Summary

First-class Functions in C++: Defining & Using First-class Functions

Course: 1 Hour, 9 Minutes

• Course Overview
• First-class Functions in C++
• Creating Function Pointers
• Invoking Functions through Function Pointers
• Returning Functions from Other Functions
• Using Typedefs and Type Aliases
• Passing Functions in as Input Arguments
• Utilizing Templates with Higher-order Functions
• Creating and Using Functors
• Using Functors with Templates
• Course Summary

First-class Functions in C++: Using Lambdas & Closures

Course: 55 Minutes

• Course Overview
• Lambda Expressions
• Creating Lambdas
• Passing Lambdas into Functions
• Using Lambdas with STL Algorithms
• Lambda Closures
• Capturing Variables within Lambdas
• Capturing Variables by Reference
• Course Summary

C++: Introduction to Graphics with SFML

Course: 1 Hour, 35 Minutes

• Course Overview
• Simple and Fast Multimedia Library (SMFL)
• Installing SFML on macOS
• Installing SFML on Windows
• Opening and Managing Windows
• Setting Window Icons and Window Properties
• Handling Focus Events and Keyboard Events
• Handling Text Entered and Mouse Events
• Drawing Text
• Drawing Rectangles and Circles
• Drawing Polygons
• Course Summary

C++: Creating a Complete Game in SFML

Course: 1 Hour, 33 Minutes

• Course Overview
• Drawing Textures and Sprites
• Drawing Using Vertex Arrays
• Moving, Rotating, and Scaling Entities
• Using Sprite Sheets for Animation
• Interacting with the World Using Views
• Playing Music in Games
• Tic-Tac-Toe: Defining the Game
• Tic-Tac-Toe: Implementing the Game
• Tic-Tac-Toe: Playing the Game
• Course Summary