C++ Programming Fundamentals for Beginners Course

Lesson 1 • Writing and Compiling Hello World

The minimal C++ source file structure is explained and compiled. Students run their first executable and read compiler output.

Lesson 2 • Installing a Compiler and IDE

Students install GCC or Clang and a code editor such as VS Code. Correct installation is verified by compiling a test file.

Lesson 3 • Navigating the Build Process

Preprocessing, compilation, and linking stages are demystified. Students understand how source files become executables.

Lesson 1 • Integer and Floating-Point Types

Signed and unsigned integer widths and floating-point precision are examined. Students choose appropriate types for given data ranges.

Lesson 2 • Constants and Type Conversions

const, constexpr, and implicit/explicit casting rules are explained. Students avoid data loss from unintended type conversions.

Lesson 3 • Characters, Booleans, and Strings

char, bool, and std::string types are introduced with their operations. Students manipulate text and logical values in small programmes.

Lesson 1 • Operator Precedence and Associativity

Precedence tables and associativity rules determine expression evaluation order. Students use parentheses to enforce intended computation.

Lesson 2 • Relational and Logical Operators

Comparison and logical operators produce bool results used in control flow. Students write conditions that combine multiple relational tests.

Lesson 3 • Arithmetic and Assignment Operators

The five arithmetic operators and compound assignment forms are practised. Students compute results and understand integer division behaviour.

Lesson 1 • Switch Statements and Enumerations

Switch provides multi-way branching on integral values; enums improve readability. Students replace long if-else chains with cleaner switch blocks.

Lesson 2 • Loop Control and Nested Loops

break, continue, and nested loop patterns extend loop capabilities. Students solve problems requiring early exit and multi-dimensional iteration.

Lesson 3 • if, else if, and else Statements

Conditional branching syntax and nesting rules are taught with practical examples. Students write programs that choose different code paths based on input.

Lesson 1 • Recursion Fundamentals

Recursive functions call themselves to solve problems defined in terms of subproblems. Students implement factorial, Fibonacci, and simple search recursively.

Lesson 2 • Function Overloading and Default Arguments

Multiple functions sharing a name and optional parameters increase API flexibility. Students design overloaded sets that compile without ambiguity.

Lesson 3 • Defining and Calling Functions

Function syntax, return types, and call mechanics are established. Students replace repeated code blocks with named, callable units.

Lesson 4 • References, Pointers as Parameters

Pass-by-reference and pass-by-pointer allow functions to modify caller data. Students choose the correct passing strategy for each use case.

Lesson 1 • Dynamic Memory Allocation

new and delete allocate and free heap memory at runtime. Students manage dynamic arrays and avoid memory leaks through disciplined deallocation.

Lesson 2 • Smart Pointers Introduction

unique_ptr and shared_ptr automate memory management using RAII. Students replace raw owning pointers with smart pointers to eliminate leaks.

Lesson 3 • Pointers and Address Arithmetic

Pointers store memory addresses and enable direct memory access. Students declare pointers, dereference them, and perform pointer arithmetic.

Lesson 4 • Arrays and Array Operations

Fixed-size arrays store homogeneous elements accessed by index. Students declare, initialise, and iterate over one-dimensional arrays safely.

Lesson 1 • Operator Overloading

Custom types gain natural syntax by overloading operators such as +, ==, and <<. Students implement arithmetic and stream operators for a user-defined class.

Lesson 2 • Polymorphism and Virtual Functions

Virtual functions enable runtime dispatch through base class pointers. Students implement a polymorphic interface and observe dynamic binding in action.

Lesson 3 • Classes, Objects, and Encapsulation

Classes bundle data and behaviour; access specifiers enforce encapsulation. Students define classes with private data and public getter/setter methods.

Lesson 4 • Constructors and Destructors

Constructors initialise objects; destructors release resources at end of lifetime. Students implement default, parameterised, and copy constructors correctly.

Lesson 1 • STL Algorithms and Iterators

Algorithms such as sort, find, and transform operate on iterator ranges. Students apply standard algorithms instead of writing manual loops.

Lesson 2 • std::map and std::set

Associative containers map keys to values and store unique sorted elements. Students implement frequency counting and lookup tables with these containers.

Lesson 3 • File I/O with fstream

ifstream and ofstream read and write text files using familiar stream syntax. Students build programs that persist data between runs.

Lesson 4 • std::vector and Dynamic Sequences

vector provides a resizable array with bounds-checked access and iterators. Students build, modify, and traverse vectors in realistic programs.