C++ Beginner Course

Lesson 1 • Understanding C++ and its uses

C++ is a compiled, statically typed language used in systems, games, and embedded software. This context motivates the toolchain choices made throughout the chapter.

Lesson 2 • Choosing and configuring an IDE

An IDE accelerates development with editing, building, and debugging in one tool. Learners configure VS Code or Code::Blocks for C++ projects.

Lesson 3 • Understanding build errors and warnings

Compiler diagnostics are the first feedback loop in C++ development. Learners learn to read error messages and fix common setup mistakes.

Lesson 4 • Writing and compiling Hello World

The classic Hello World program introduces the minimal structure of a C++ source file. Learners compile and run it to confirm the full toolchain works.

Lesson 1 • Arithmetic and assignment operators

Arithmetic operators perform maths on numeric types; assignment operators update variables concisely. Learners write expressions combining both operator groups.

Lesson 2 • Fundamental data types

C++ provides integer, floating-point, character, and boolean types with defined sizes. Learners choose appropriate types for given data requirements.

Lesson 3 • Type conversions and casting

Implicit conversions can cause data loss; explicit casts make intent clear. Learners identify unsafe conversions and apply static_cast correctly.

Lesson 4 • Constants and literals

Constants prevent accidental modification of fixed values. Learners use const, constexpr, and typed literals to express immutable data clearly.

Lesson 1 • Reading full lines of text

std::getline reads an entire line including spaces, unlike the extraction operator. Learners combine getline with cin correctly to avoid common pitfalls.

Lesson 2 • Introduction to std::string

std::string is the standard class for text data in C++. Learners create, assign, and concatenate strings using its member functions.

Lesson 3 • Console output with std::cout

std::cout sends formatted text to the terminal using the insertion operator. Learners control spacing, newlines, and numeric formatting in output.

Lesson 4 • Reading input with std::cin

std::cin reads whitespace-delimited tokens from the keyboard into variables. Learners handle simple input scenarios and detect basic input failures.

Lesson 1 • for and while loops

for loops iterate a known number of times; while loops repeat while a condition holds. Learners choose the right loop type and write correct loop conditions.

Lesson 2 • Boolean expressions and comparisons

Conditions are built from relational and logical operators that evaluate to true or false. Learners construct compound conditions for realistic decision scenarios.

Lesson 3 • do-while, break, and continue

do-while guarantees at least one execution; break and continue alter loop flow mid-iteration. Learners apply these constructs to input validation and search tasks.

Lesson 4 • if, else if, and else statements

if-else chains select one code path from several alternatives based on conditions. Learners structure multi-branch logic clearly and avoid dangling-else issues.

Lesson 1 • Return values and multiple outputs

Functions communicate results through return values or output parameters. Learners return structured data and use reference parameters for multiple outputs.

Lesson 2 • Defining and calling functions

A function encapsulates a named block of reusable logic. Learners write function definitions, declarations, and call sites with matching argument types.

Lesson 3 • Function overloading

Overloading lets multiple functions share a name when their parameter lists differ. Learners define overloaded functions and understand how the compiler resolves calls.

Lesson 4 • Parameters and arguments

Parameters define the inputs a function expects; arguments supply the actual values. Learners distinguish pass-by-value from pass-by-reference and choose appropriately.

Lesson 1 • Sorting and searching collections

The standard library provides efficient sort and search algorithms for vectors. Learners apply std::sort and std::binary_search with default and custom comparators.

Lesson 2 • Introduction to std::array and std::string

std::array wraps a fixed-size raw array with a safer, STL-compatible interface. Learners compare std::array, raw arrays, and vectors to choose the right container.

Lesson 3 • Common vector operations

Vectors support insertion, deletion, and searching beyond simple push and pop. Learners use insert, erase, and find to manipulate vector contents precisely.

Lesson 4 • Raw arrays in C++

Raw arrays store fixed-size sequences of a single type in contiguous memory. Learners declare, initialise, and access array elements while respecting bounds.

Lesson 1 • Smart pointers introduction

Smart pointers automate memory management and prevent leaks. Learners use std::unique_ptr for exclusive ownership and std::shared_ptr for shared ownership scenarios.

Lesson 2 • Dereferencing and pointer arithmetic

Dereferencing a pointer accesses the value at its stored address. Learners perform pointer arithmetic to traverse arrays and understand the relationship between arrays and pointers.

Lesson 3 • References vs. pointers

References are aliases that cannot be null or reseated; pointers are flexible but riskier. Learners choose between references and pointers based on ownership and nullability needs.

Lesson 4 • Dynamic memory allocation

new and delete allocate and free heap memory at runtime. Learners manage single objects and arrays on the heap and identify memory leaks.

Lesson 1 • Basic inheritance and polymorphism

Inheritance lets a derived class reuse and extend a base class. Learners create a simple class hierarchy and call overridden virtual functions through base pointers.

Lesson 2 • Defining and using structs

Structs group related data fields under a single name. Learners define structs, create instances, and access members to represent compound data.

Lesson 3 • Member functions and methods

Member functions operate on an object's data and define its behaviour. Learners implement const member functions and understand how methods access private data.

Lesson 4 • Introducing classes and encapsulation

Classes add access control to group data and behaviour together. Learners use public and private to enforce encapsulation and expose safe interfaces.