The Complete C++ Programming Course

Lesson 1: C++ Syntax and Basic Structure

Welcome to the first lesson of our C++ programming course. Today, we'll lay the foundation by understanding the basic syntax and structure of a C++ program. Every journey begins with a single step, and for C++, that step is learning how to write a simple program that compiles and runs successfully. This knowledge is crucial as it forms the skeleton upon which all your future projects will be built. We'll start with the "Hello, World!" program, which is the traditional first program for most programming languages, and then break down each component to understand its role. This approach ensures you're not just copying code, but truly comprehending its meaning. Understanding the fundamental structure will make it easier to write more complex programs later, as you'll always have a reliable template to start from.

The core of any C++ program is the main() function. This is the entry point of your program. When you run an executable, the operating system looks for this function and starts its execution there. Without a main() function, your program cannot be compiled and run. The structure of the main() function is typically int main() { ... } or int main(int argc, char* argv[]) { ... }. The int indicates that the function will return an integer value to the operating system upon completion. A return value of 0 traditionally signifies that the program executed successfully without any errors. Other return values can indicate different types of errors or statuses. The parentheses after main are for arguments that can be passed to the program from the command line, which we'll explore in a later lesson.

The "Hello, World!" Program Explained

Let's look at the canonical "Hello, World!" example and dissect its parts. This simple program will print the text "Hello, World!" to the console. It's the perfect starting point to understand the key elements of C++ syntax.

#include <iostream>

int main() {
    std::cout << "Hello, World!" << std::endl;
    return 0;
}

Let's break down this code line by line:

• #include <iostream>: This is a preprocessor directive. The #include command tells the compiler to include the contents of a specified file. In this case, <iostream> is a standard library that handles input and output operations, such as printing text to the console. It provides the std::cout object, which we use for output.
• int main() { ... }: As discussed, this is the main function. The curly braces { and } define the **scope** or **body** of the function, containing all the statements that will be executed when the program runs.
• std::cout << "Hello, World!" << std::endl;: This is the statement that performs the actual output. std::cout is the standard character output stream. The << operator, known as the stream insertion operator, sends the string literal "Hello, World!" to std::cout. std::endl is a manipulator that inserts a newline character and flushes the output buffer.
• return 0;: This statement ends the main() function and returns the integer value 0 to the operating system, signaling successful completion.

One of the most critical aspects of C++ syntax is the use of the **semicolon** (;). In C++, every statement must end with a semicolon. It acts as a terminator, telling the compiler that the current instruction is complete. Forgetting a semicolon is one of the most common errors for new C++ programmers, leading to a "syntax error" during compilation. You'll also encounter comments, which are used to add notes to your code that the compiler ignores. C++ supports two types of comments: single-line comments starting with // and multi-line comments enclosed between /* and */. Using comments effectively is a best practice for writing clean, readable, and maintainable code. They are not just for your own benefit, but also for any other developer who might need to read or work with your code in the future.

#include <iostream>

int main() {
    // This is a single-line comment
    std::cout << "Hello, my name is [Your Name]!" << std::endl;

    /*
     * This is a multi-line comment.
     * The program will now print a welcome message.
     */
    std::cout << "Welcome to the world of C++ programming." << std::endl;

    return 0;
}

Lesson 2: Variables, Data Types, and Constants

In our journey through C++, variables are the fundamental building blocks for storing and manipulating data. Think of a variable as a labeled box in your computer's memory where you can store a value. To use a variable, you must first declare it, which involves giving it a name and specifying its data type. The data type tells the compiler what kind of data the variable will hold (e.g., a number, a character, or a true/false value) and how much memory to allocate for it. Choosing the correct data type is crucial for efficient memory usage and to prevent unexpected errors. For example, trying to store a large number in a variable designed for small numbers can lead to overflow issues, where the value wraps around and becomes incorrect. C++ is a strongly-typed language, meaning you must be explicit about the data types you use, which helps catch many errors during the compilation process rather than at runtime.

C++ offers a rich set of built-in, or primitive, data types. The most common ones you'll use are:

• int: Used to store whole numbers (integers), such as $10$, $-5$, or $0$. The size of an int is typically 4 bytes, but this can vary depending on the system architecture.
• float: Used for single-precision floating-point numbers (numbers with a decimal point), like $3.14$ or $-0.5$. It typically occupies 4 bytes of memory.
• double: Used for double-precision floating-point numbers. It offers greater precision than a float and is the default type for decimal numbers in C++. It typically takes up 8 bytes.
• char: Used to store a single character, like 'A', 'b', or '!'. A char is often stored as an integer that corresponds to a character in the ASCII table. It occupies 1 byte.
• bool: Used to store boolean values, which can be either true or false. This is essential for control flow and conditional logic. It typically takes up 1 byte.

You can declare a variable by writing its type followed by its name, and you can optionally initialize it with a value at the same time. This practice of initialization is highly recommended to avoid working with unpredicted garbage values in memory. For example, to declare an integer variable named age and initialize it to 30, you would write int age = 30;. C++ also provides type modifiers like short, long, signed, and unsigned that you can use with integer types to further control the range of values they can hold. For instance, an unsigned int can only hold non-negative values, doubling its positive range compared to a signed int.

Constants: Values that Don't Change

In contrast to variables, constants are values that cannot be changed after they are initialized. They are a way to make your code more readable, prevent accidental modifications, and often allow the compiler to perform optimizations. You declare a constant using the const keyword. A common use case for constants is to define fixed values, such as the value of $\pi$ or a maximum size for an array. For example, const double PI = 3.14159;. Once declared, any attempt to change the value of PI will result in a compilation error. This provides a valuable safety net in your code. C++11 introduced the constexpr keyword, which stands for "constant expression." It is a more powerful form of const, guaranteeing that a value is a compile-time constant, which can lead to even better performance optimizations.

#include <iostream>

int main() {
    // Variable declaration and initialization
    int age = 25;
    double price = 19.99;
    char grade = 'A';
    bool isActive = true;

    // Constants
    const double PI = 3.14159;
    constexpr int MAX_USERS = 1000;

    std::cout << "Age: " << age << std::endl;
    std::cout << "Price: $" << price << std::endl;
    std::cout << "Grade: " << grade << std::endl;
    std::cout << "Is Active: " << isActive << std::endl;
    std::cout << "Pi (constant): " << PI << std::endl;

    // Trying to change a constant will cause a compile-time error
    // PI = 3.0; // This line would fail to compile

    return 0;
}

#include <iostream>

int main() {
    // Declare a variable for height (in meters)
    double height = 1.75;
    // For now, let's just use a single character for a name's first initial
    char initial = 'J';

    // Declare a constant for gravity
    const double GRAVITY = 9.81;

    std::cout << "Initial: " << initial << std::endl;
    std::cout << "Height: " << height << " meters" << std::endl;
    std::cout << "Gravity (constant): " << GRAVITY << " m/s^2" << std::endl;

    return 0;
}

Lesson 3: Operators and Control Structures

Now that we understand how to store data in variables, we need to learn how to manipulate that data and make decisions in our programs. This is where operators and control structures come into play. Operators are symbols that perform operations on variables and values. Control structures, on the other hand, are statements that control the flow of execution in your program, allowing you to make decisions or repeat a block of code. Mastering these two concepts is essential for writing any non-trivial program. Without them, your program would simply execute a sequence of statements from top to bottom without any logic or ability to respond to different conditions.

Understanding Operators in C++

C++ has a rich set of operators, which can be categorized into several groups:

• Arithmetic Operators: These are used for mathematical operations:
  • + (addition), - (subtraction), * (multiplication), / (division), % (modulus)
• Assignment Operators: Used to assign values to variables:
  • = (simple assignment), +=, -=, *=, /=, etc. (compound assignments)
• Comparison Operators: Used to compare two values. They return a boolean value (true or false):
  • == (equal to), != (not equal to), > (greater than), < (less than), >= (greater than or equal to), <= (less than or equal to)
• Logical Operators: Used to combine or modify boolean expressions:
  • && (logical AND), || (logical OR), ! (logical NOT)

The order in which these operators are evaluated is determined by their **precedence** and **associativity**. For example, multiplication and division have higher precedence than addition and subtraction. Parentheses can always be used to override the default order of evaluation and make your intentions clear, which is a good practice to prevent bugs and improve code readability.

Controlling Program Flow with Control Structures

Control structures are statements that allow you to dictate the order in which code is executed. They are the backbone of program logic. The most common control structures are:

• if, else if, else: This is a conditional statement that executes a block of code only if a specified condition is true. The else if and else clauses provide alternative paths of execution if the initial condition is false.
• switch: A powerful alternative to a long chain of if-else if statements. It allows a program to execute different blocks of code based on the value of a single variable.
• for loop: Used to execute a block of code a specific number of times. It's perfect for iterating over arrays or performing repetitive tasks where you know the exact number of iterations in advance.
• while loop: Executes a block of code as long as a specified condition is true. It's useful when you don't know the number of iterations beforehand.
• do-while loop: Similar to a while loop, but it guarantees that the code block will be executed at least once before the condition is checked.

Using these structures, you can create programs that are dynamic and can react to different inputs and states. For example, you can write a program that asks a user for a number and then prints whether it is even or odd, using an if-else statement and the modulus operator. The ability to control the flow of your program is what separates a simple script from a sophisticated application.

#include <iostream>

int main() {
    int x = 10;
    int y = 5;

    // Arithmetic operators
    int sum = x + y;
    int product = x * y;

    // Comparison and Logical operators
    bool isGreater = (x > y) && (y > 0);

    std::cout << "Sum: " << sum << std::endl;
    std::cout << "Product: " << product << std::endl;

    // Control structure: if-else statement
    if (sum > 20) {
        std::cout << "Sum is greater than 20." << std::endl;
    } else if (sum == 15) {
        std::cout << "Sum is exactly 15." << std::endl;
    } else {
        std::cout << "Sum is not greater than 20 and not exactly 15." << std::endl;
    }

    // Control structure: for loop
    for (int i = 0; i < 3; ++i) {
        std::cout << "Loop iteration " << i << std::endl;
    }

    return 0;
}

#include <iostream>

int main() {
    int userNumber;
    std::cout << "Please enter an integer: ";
    std::cin >> userNumber; // Read an integer from the user

    if (userNumber > 0) {
        std::cout << "The number is positive. Counting down:" << std::endl;
        for (int i = userNumber; i > 0; --i) {
            std::cout << i << "..." << std::endl;
        }
    } else if (userNumber < 0) {
        std::cout << "The number is negative." << std::endl;
    } else {
        std::cout << "The number is zero." << std::endl;
    }

    return 0;
}

Lesson 4: Functions and Function Overloading

As our programs become more complex, it becomes inefficient and hard to manage to have all our code in the main() function. This is where functions come in. A function is a named, reusable block of code that performs a specific task. By breaking down your program into smaller, manageable functions, you can improve its organization, readability, and maintainability. Functions promote the principle of "Don't Repeat Yourself" (DRY), as you can write a piece of code once and call it from multiple places. They also help in modularizing your code, making it easier to debug and test individual components independently. When you call a function, you can pass it data (arguments) and it can return a result, making it a powerful tool for computation and data processing.

To define a function, you must specify its **return type**, its **name**, and the parameters it accepts in parentheses. The return type specifies the data type of the value the function will return. If a function does not return a value, its return type is void. The parameters are variables that the function can use to receive input values. After the function header, a set of curly braces {} encloses the function body, which contains the code to be executed. To use a function, you simply "call" it by its name, followed by parentheses containing any required arguments. The compiler must know about a function's existence before it is called. This is typically done by declaring a **function prototype** at the beginning of your file or by defining the function before it is called.

The Power of Function Overloading

One of C++'s most powerful features is function overloading. This allows you to define multiple functions with the same name, as long as they have different **parameter lists**. The parameter list includes the number, type, and order of the function's parameters. This means you can write a single function name, for example, add, that can work with different data types, such as integers, doubles, or even custom classes. The compiler determines which version of the function to call based on the arguments you pass to it. This feature provides a clean and intuitive interface for your code, as you don't need to come up with different names like addInts, addDoubles, etc. for every data type. The overloaded function name acts as a single, consistent interface for a conceptually similar operation, making your code much more readable and flexible.

#include <iostream>

// Function to add two integers
int add(int a, int b) {
    return a + b;
}

// Overloaded function to add two doubles
double add(double a, double b) {
    return a + b;
}

// Function with a void return type and no parameters
void sayHello() {
    std::cout << "Hello from a function!" << std::endl;
}

int main() {
    sayHello();

    int intSum = add(5, 10);
    double doubleSum = add(3.14, 2.71);

    std::cout << "Integer sum: " << intSum << std::endl;
    std::cout << "Double sum: " << doubleSum << std::endl;

    return 0;
}

#include <iostream>

// Function to calculate and print the area of a square
void printArea(int side) {
    std::cout << "The area of the square is: " << side * side << std::endl;
}

// Overloaded function to calculate and print the area of a rectangle
void printArea(double length, double width) {
    std::cout << "The area of the rectangle is: " << length * width << std::endl;
}

int main() {
    printArea(5); // Calls the first version
    printArea(10.5, 4.2); // Calls the second version
    return 0;
}

Lesson 5: Arrays and Pointers

In this lesson, we delve into two of the most fundamental and powerful concepts in C++: arrays and pointers. These concepts are deeply intertwined and are essential for managing collections of data and directly interacting with memory. An array is a collection of elements of the same data type, stored in contiguous memory locations. It allows you to store a fixed number of elements under a single variable name, which is incredibly useful for organizing related data. For instance, you could use an array to store the scores of 10 students or the temperatures recorded over a week. The elements of an array can be accessed using an index, which is an integer value that starts from 0 for the first element. Understanding arrays is the first step towards managing structured data in C++ effectively.

A pointer is a variable that stores a memory address as its value. Instead of holding data directly, it "points" to the location where the data is stored. Pointers are a cornerstone of C++ and give you a low-level control over memory that is not available in many other high-level languages. This direct access allows for highly efficient code, especially when working with large data sets, but it also comes with responsibility. Misusing pointers can lead to serious errors like memory leaks, segmentation faults, and undefined behavior. The relationship between arrays and pointers is particularly strong: an array's name often acts as a pointer to its first element. This means you can use pointer arithmetic to traverse an array, which can sometimes be more efficient than using a traditional index. The ability to manipulate memory directly through pointers is what gives C++ its power and performance advantage in system programming and other low-level applications.

Declaration and Usage

To declare an array, you specify the data type, the name of the array, and the number of elements in square brackets. For example, int numbers[5]; declares an array named numbers that can hold 5 integers. You can initialize an array at the time of declaration, like this: int scores[3] = {85, 92, 78};. To access or modify an element, you use the array name followed by the index in square brackets, for example, scores[0] = 90; would change the first element. When you declare a pointer, you use the asterisk (*) symbol. For example, int* ptr; declares a pointer named ptr that can hold the address of an integer. To get the address of a variable, you use the address-of operator (&), as in ptr = &some_variable;. The dereference operator (*) is used to access the value at the memory address stored in the pointer, for example, int value = *ptr;.

The synergy between arrays and pointers is key. When you pass an array to a function, you are actually passing a pointer to its first element. This is why you need to pass the size of the array separately to the function so that it knows how many elements to process. The following code demonstrates the basic usage of both arrays and pointers, including their interaction. Pay close attention to the syntax for declaration, initialization, and dereferencing, as this is a common source of confusion for new C++ programmers.

#include <iostream>

void printArray(int arr[], int size) {
    for (int i = 0; i < size; ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;
}

int main() {
    // Array declaration and initialization
    int scores[] = {85, 92, 78, 95};
    int size = sizeof(scores) / sizeof(scores[0]);

    // Pointer declaration
    int* scorePtr;
    scorePtr = &scores[0]; // Or simply: scorePtr = scores;

    std::cout << "Values in the array: ";
    printArray(scores, size);

    std::cout << "Value pointed to by scorePtr: " << *scorePtr << std::endl;

    // Pointer arithmetic to access the next element
    scorePtr++;
    std::cout << "Value of the next element: " << *scorePtr << std::endl;

    return 0;
}

#include <iostream>

int main() {
    float numbers[5] = {1.1, 2.2, 3.3, 4.4, 5.5};
    float* ptr = numbers; // Pointer to the first element
    float sum = 0.0;

    std::cout << "Elements in the array: ";
    for (int i = 0; i < 5; ++i) {
        std::cout << *ptr << " ";
        sum += *ptr;
        ptr++; // Move the pointer to the next element
    }
    std::cout << std::endl;

    std::cout << "Sum of elements: " << sum << std::endl;

    return 0;
}

Lesson 1: Classes and Objects

Welcome to Module 2, where we transition from procedural programming to the core of C++'s power: Object-Oriented Programming (OOP). At its heart, OOP is a programming paradigm based on the concept of "objects," which can contain data, in the form of fields (often known as attributes or properties), and code, in the form of procedures (often known as methods). This approach allows you to model real-world concepts in your code, making programs more intuitive, modular, and easier to manage. A **class** is the blueprint or template for creating objects. It defines the structure and behavior that all objects of that class will have. An **object**, on the other hand, is an instance of a class. Think of a class like the blueprint for a house: it defines the number of rooms, the layout, and the materials. An object is an actual, physical house built from that blueprint. You can have many different houses (objects) all built from the same blueprint (class), each with its own unique characteristics (e.g., color, address).

A key concept of OOP is **encapsulation**, which is the bundling of data and the methods that operate on that data into a single unit (the class). It also involves hiding the internal implementation details of an object and only exposing a public interface. In C++, this is achieved using **access specifiers**: `public`, `private`, and `protected`. Public members are accessible from outside the class, forming its public interface. Private members are only accessible from within the class itself, protecting the data from being accidentally or maliciously modified. Protected members are similar to private but can also be accessed by derived classes (which we will cover in the lesson on inheritance). Encapsulation is a crucial principle for writing robust and maintainable code. It prevents the state of an object from being corrupted by outside code and allows the internal implementation to be changed without affecting the rest of the program, as long as the public interface remains the same. This separation of interface and implementation is a powerful design technique.

Defining and Using a Class

To define a class in C++, you use the `class` keyword followed by the class name. Inside the class definition, you declare the member variables and member functions, along with their access specifiers. Let's create a simple `Car` class to illustrate the concept. This class might have private member variables like `make`, `model`, and `year`, and public member functions like `startEngine()` and `getCarInfo()`. The member functions are the interface through which the outside world can interact with the car object. The data inside the car, its `make` and `model`, is protected from direct access. To create an object from this class, you simply declare a variable of that class type, for example, `Car myCar;`. You can then call the public member functions using the dot operator (`.`), as in `myCar.startEngine();`. This simple pattern of defining a class and then creating objects from it forms the basis of all Object-Oriented programming in C++ and is the key to building large, well-structured applications.

#include <iostream>
#include <string>

// A simple C++ class
class Car {
private:
    // Private member variables (attributes)
    std::string make;
    std::string model;
    int year;

public:
    // Public member functions (methods)
    void setCarDetails(std::string m, std::string mod, int y) {
        make = m;
        model = mod;
        year = y;
    }

    void displayCarDetails() {
        std::cout << "Make: " << make << ", Model: " << model << ", Year: " << year << std::endl;
    }
};

int main() {
    // Create an object of the Car class
    Car myCar;

    // Use the public member functions to interact with the object
    myCar.setCarDetails("Toyota", "Camry", 2022);
    myCar.displayCarDetails();

    return 0;
}

#include <iostream>
#include <string>

class Book {
private:
    std::string title;
    std::string author;

public:
    void setTitle(std::string t) {
        title = t;
    }

    void setAuthor(std::string a) {
        author = a;
    }

    void displayBookInfo() {
        std::cout << "Title: \"" << title << "\", Author: " << author << std::endl;
    }
};

int main() {
    Book myBook;
    myBook.setTitle("The Hitchhiker's Guide to the Galaxy");
    myBook.setAuthor("Douglas Adams");
    myBook.displayBookInfo();

    return 0;
}

Lesson 2: Constructors and Destructors

In our last lesson, we learned about classes and objects. Now, we'll dive into two special member functions that are essential for the lifecycle of an object: **constructors** and **destructors**. A constructor is a special member function that is automatically called when an object is created. Its primary purpose is to initialize the object's member variables and to perform any setup required for the object to be in a valid, usable state. It ensures that an object is properly configured from the moment it comes into existence. Without a constructor, the member variables would hold garbage values, leading to unpredictable program behavior. A constructor has the same name as the class and does not have a return type, not even `void`. C++ provides a default constructor if you don't define one, but this default constructor does not perform any initialization on primitive types, which is why it's a best practice to always provide your own constructors for proper initialization.

A **destructor** is the counterpart to a constructor. It is a special member function that is automatically called when an object is destroyed or goes out of scope. Its main purpose is to clean up any resources the object may have acquired during its lifetime. This is particularly important for dynamically allocated memory, file handles, or network connections. If you don't properly clean up these resources, your program can suffer from **resource leaks**, which can lead to performance degradation and even system instability. A destructor also has the same name as the class, but it is preceded by a tilde (`~`). Like constructors, destructors do not have a return type and cannot accept any parameters. There can only be one destructor for a class. The destructor's role is to ensure that your program leaves a clean footprint, freeing up all memory and resources it used, which is a key part of responsible programming in C++.

Types of Constructors

C++ offers several types of constructors. The most common is the **default constructor**, which takes no arguments. You can also define **parameterized constructors** to allow for object creation with initial values. For example, a `Rectangle` class could have a parameterized constructor that takes `length` and `width` as arguments. C++ also has a **copy constructor**, which is used to create a new object as a copy of an existing object. We'll discuss this in more detail in the memory management module, as it's critical for preventing shallow copies with dynamic memory. The presence of a constructor with parameters can prevent the compiler from generating a default constructor, which is an important detail to remember when designing your classes. In many cases, you might want to provide both a default constructor and one or more parameterized constructors to offer flexibility in how your objects are created.

#include <iostream>
#include <string>

class Dog {
private:
    std::string name;
    int age;

public:
    // Default constructor
    Dog() {
        std::cout << "A new dog object has been created (default constructor)." << std::endl;
        name = "Unknown";
        age = 0;
    }

    // Parameterized constructor
    Dog(std::string dogName, int dogAge) {
        std::cout << "A new dog object with name " << dogName << " has been created (parameterized constructor)." << std::endl;
        name = dogName;
        age = dogAge;
    }

    // Destructor
    ~Dog() {
        std::cout << "Dog object '" << name << "' is being destroyed." << std::endl;
    }

    void displayInfo() {
        std::cout << "Name: " << name << ", Age: " << age << std::endl;
    }
};

int main() {
    Dog myDog; // Calls the default constructor
    myDog.displayInfo();

    Dog yourDog("Buddy", 5); // Calls the parameterized constructor
    yourDog.displayInfo();

    return 0; // Objects are destroyed here when they go out of scope
}

#include <iostream>

class Rectangle {
private:
    double width;
    double height;

public:
    // Parameterized constructor
    Rectangle(double w, double h) {
        width = w;
        height = h;
        std::cout << "Rectangle object with dimensions " << width << "x" << height << " created." << std::endl;
    }

    // Destructor
    ~Rectangle() {
        std::cout << "Rectangle object with dimensions " << width << "x" << height << " destroyed." << std::endl;
    }
};

int main() {
    Rectangle rect1(10.5, 20.0);
    Rectangle rect2(5.0, 5.0);

    return 0;
}

Lesson 3: Inheritance and Polymorphism

Two of the most powerful pillars of Object-Oriented Programming are **inheritance** and **polymorphism**. Inheritance allows you to define a new class (the **derived** or **child** class) based on an existing class (the **base** or **parent** class). The derived class inherits all the members (variables and functions) of the base class. This is a crucial mechanism for code reuse and for establishing a hierarchical relationship between classes, representing an "is-a" relationship. For example, a `Dog` "is a" `Animal`, so a `Dog` class could inherit from an `Animal` base class. This means the `Dog` class automatically gets all the attributes and behaviors of an `Animal`, such as `age` and `eat()`, without having to rewrite them. Inheritance promotes a cleaner, more organized code base and simplifies future modifications, as a change to the base class can be automatically propagated to all derived classes.

**Polymorphism** is a Greek word that means "many forms." In C++, it refers to the ability of a single function or object to take on many forms. Specifically, it allows objects of different classes that are part of the same inheritance hierarchy to be treated as if they were objects of the base class. This is achieved through **virtual functions** and pointers or references to the base class. The key idea is that a function call can behave differently depending on the type of the object it is called on, even if the object is being accessed through a base class pointer. This dynamic behavior is resolved at runtime and is fundamental to creating flexible and extensible systems. Without polymorphism, you would have to write complex `if-else` or `switch` statements to check the type of an object and call the appropriate function, which would make your code brittle and hard to maintain. Polymorphism is what enables the elegant and powerful design patterns that are common in C++ development.

Putting It All Together: A Practical Example

Let's illustrate these concepts with a classic example involving shapes. We can have a base class `Shape` with a member function `draw()`. Then, we can have derived classes like `Circle` and `Square` that inherit from `Shape`. Each derived class can provide its own unique implementation of the `draw()` function. Polymorphism comes into play when you create an array of `Shape` pointers and store objects of `Circle` and `Square` in it. When you loop through this array and call `draw()` on each pointer, the correct `draw()` function for each specific object (Circle or Square) is called automatically at runtime. This dynamic dispatch is a powerful feature and is a core reason why C++ is so well-suited for building complex software architectures. The ability to treat different objects uniformly through a common interface, even when their underlying implementations differ, makes for highly flexible and scalable code. This is what makes polymorphism so essential for building systems that can be easily extended with new types in the future without modifying existing code.

#include <iostream>
#include <string>
#include <vector>

// Base class
class Animal {
protected:
    std::string name;
public:
    Animal(std::string n) : name(n) {}
    virtual void speak() { // The 'virtual' keyword enables polymorphism
        std::cout << "Animal makes a sound." << std::endl;
    }
};

// Derived class
class Dog : public Animal {
public:
    Dog(std::string n) : Animal(n) {}
    void speak() override { // 'override' is a C++11 keyword that checks if the function overrides a virtual function
        std::cout << "Dog named " << name << " barks." << std::endl;
    }
};

// Another derived class
class Cat : public Animal {
public:
    Cat(std::string n) : Animal(n) {}
    void speak() override {
        std::cout << "Cat named " << name << " meows." << std::endl;
    }
};

int main() {
    Dog myDog("Buddy");
    Cat myCat("Whiskers");

    // Using a base class pointer to demonstrate polymorphism
    Animal* animalPtr1 = &myDog;
    Animal* animalPtr2 = &myCat;

    animalPtr1->speak(); // Outputs "Dog named Buddy barks."
    animalPtr2->speak(); // Outputs "Cat named Whiskers meows."
    
    // Using a vector of base class pointers
    std::vector zoo;
    zoo.push_back(&myDog);
    zoo.push_back(&myCat);

    std::cout << "\nDemonstrating polymorphism with a vector:" << std::endl;
    for (const auto& animal : zoo) {
        animal->speak();
    }

    return 0;
}

#include <iostream>
#include <string>

class Vehicle {
protected:
    std::string brand;
public:
    Vehicle(std::string b) : brand(b) {}
    virtual void drive() {
        std::cout << "Driving a generic vehicle." << std::endl;
    }
};

class Car : public Vehicle {
public:
    Car(std::string b) : Vehicle(b) {}
    void drive() override {
        std::cout << "Driving a " << brand << " car." << std::endl;
    }
};

class Motorcycle : public Vehicle {
public:
    Motorcycle(std::string b) : Vehicle(b) {}
    void drive() override {
        std::cout << "Riding a " << brand << " motorcycle." << std::endl;
    }
};

int main() {
    Car myCar("Honda");
    Motorcycle myMotorcycle("Harley-Davidson");

    Vehicle* v1 = &myCar;
    Vehicle* v2 = &myMotorcycle;

    v1->drive();
    v2->drive();

    return 0;
}

Lesson 4: Virtual Functions and Abstract Classes

Building on our understanding of polymorphism, this lesson focuses on two key features that enable it: **virtual functions** and **abstract classes**. A virtual function is a member function in a base class that you expect to be redefined in a derived class. By declaring a function as `virtual`, you are telling the compiler to resolve the function call at runtime, based on the actual type of the object, rather than at compile time, based on the type of the pointer or reference. This is the mechanism behind polymorphism. The `virtual` keyword is the key to achieving dynamic dispatch. Without it, a base class pointer would always call the base class's version of the function, even if the pointer was pointing to a derived class object, defeating the purpose of polymorphism. A best practice introduced in C++11 is to use the `override` keyword when redefining a virtual function in a derived class. This keyword tells the compiler to check that a function with that exact signature exists in the base class, helping you catch potential errors early in the development cycle. The combination of `virtual` and `override` is a powerful tool for building robust and flexible class hierarchies.

An **abstract class** takes this concept a step further. It is a class that is designed to be a base class and cannot be instantiated on its own. An abstract class is defined by having at least one **pure virtual function**. A pure virtual function is a virtual function with a special syntax: it is declared with `= 0` at the end of its declaration. A pure virtual function has no implementation in the abstract base class; it must be implemented by any concrete (non-abstract) derived class. This forces all derived classes to provide their own implementation for that function, ensuring that all objects in the hierarchy have a consistent interface. An abstract class serves as a conceptual model, defining a common contract that all its child classes must follow. For example, a `Shape` class could be abstract with a pure virtual `area()` function, forcing `Circle` and `Square` classes to provide their own specific `area()` calculations. This design pattern guarantees that any `Shape` object, regardless of its specific type, can be relied upon to have an `area()` function, which is a powerful guarantee for building flexible and maintainable systems.

Pure Virtual Functions in Practice

Let's revisit our `Animal` example. We can make the `Animal` class abstract by making `speak()` a pure virtual function. This would mean you could no longer create a generic `Animal` object directly, only `Dog` or `Cat` objects. This makes perfect sense in a real-world scenario, as a generic "animal" doesn't have a specific sound; only specific types of animals do. The pure virtual function forces the derived classes to implement a concrete `speak()` method. A class that inherits from an abstract class but fails to implement all of its pure virtual functions will itself become an abstract class. This is a powerful feature that ensures a well-defined and predictable class hierarchy, preventing the creation of incomplete or non-functional objects. This strict enforcement of the interface is a key benefit of using abstract classes and pure virtual functions, and it is a common design pattern in complex C++ applications where you want to ensure a certain behavior exists across all derived classes.

#include <iostream>
#include <string>

// Abstract base class
class Shape {
public:
    // Pure virtual function
    virtual double area() const = 0;
    virtual void display() const = 0;
};

// Derived class
class Circle : public Shape {
private:
    double radius;
public:
    Circle(double r) : radius(r) {}
    double area() const override {
        return 3.14159 * radius * radius;
    }
    void display() const override {
        std::cout << "This is a Circle with area " << area() << std::endl;
    }
};

// Another derived class
class Rectangle : public Shape {
private:
    double width;
    double height;
public:
    Rectangle(double w, double h) : width(w), height(h) {}
    double area() const override {
        return width * height;
    }
    void display() const override {
        std::cout << "This is a Rectangle with area " << area() << std::endl;
    }
};

int main() {
    // Shape shape; // This would cause a compile-time error! Cannot instantiate an abstract class.

    Circle myCircle(5.0);
    Rectangle myRectangle(4.0, 6.0);

    // Using base class pointers for polymorphism
    Shape* shapePtr1 = &myCircle;
    Shape* shapePtr2 = &myRectangle;

    shapePtr1->display();
    shapePtr2->display();

    return 0;
}

#include <iostream>
#include <string>
#include <vector>

class Employee {
protected:
    std::string name;
public:
    Employee(std::string n) : name(n) {}
    virtual double calculateSalary() = 0;
};

class FullTimeEmployee : public Employee {
private:
    double annualSalary;
public:
    FullTimeEmployee(std::string n, double salary) : Employee(n), annualSalary(salary) {}
    double calculateSalary() override {
        return annualSalary / 12.0; // Monthly salary
    }
};

class PartTimeEmployee : public Employee {
private:
    double hourlyRate;
    int hoursWorked;
public:
    PartTimeEmployee(std::string n, double rate, int hours) : Employee(n), hourlyRate(rate), hoursWorked(hours) {}
    double calculateSalary() override {
        return hourlyRate * hoursWorked;
    }
};

int main() {
    std::vector employees;
    FullTimeEmployee emp1("Alice", 60000.0);
    PartTimeEmployee emp2("Bob", 15.0, 80);

    employees.push_back(&emp1);
    employees.push_back(&emp2);

    for (const auto& emp : employees) {
        std::cout << "Monthly Salary: $" << emp->calculateSalary() << std::endl;
    }

    return 0;
}

Lesson 5: Operator Overloading

In this final lesson of our OOP module, we will explore a powerful feature that allows you to redefine how standard C++ operators work with your custom data types: **operator overloading**. By default, operators like `+`, `-`, `==`, etc., are defined to work with primitive data types such as `int` or `double`. However, C++ allows you to provide a special implementation for these operators to work with your own classes. This makes your custom classes more intuitive and easier to use. For example, if you have a `Vector2D` class, it would be much more natural to add two vectors using the `+` operator, like `Vector2D c = a + b;`, rather than having to call a member function like `c = a.add(b);`. Operator overloading gives your custom types the same expressive power as built-in types, leading to code that is more readable and closely resembles mathematical notation.

To overload an operator, you define a special function using the `operator` keyword followed by the operator symbol you want to overload. For binary operators (like `+` or `*`), this function can either be a member function of the class (taking one argument) or a non-member, non-friend function (taking two arguments). For unary operators (like `++` or `-`), the function takes one argument. The `this` pointer in a member function implicitly refers to the left-hand operand. When deciding whether to use a member function or a non-member function, a good rule of thumb is to use a member function for operators that modify the object itself (like `+=`), and a non-member function for operators that return a new object (like `+`). Friend functions are also an option for non-member functions if they need access to the private members of a class. The `friend` keyword allows a non-member function or another class to access the private and protected members of a class, which can be useful but should be used sparingly to avoid breaking the principle of encapsulation.

A Practical Example with Complex Numbers

Let's consider a `Complex` class to represent complex numbers, which have a real and an imaginary part. It would be incredibly useful to be able to add two `Complex` objects using the `+` operator. We can achieve this by overloading the `+` operator. The overloaded function would take another `Complex` object as an argument and return a new `Complex` object that is the sum of the two. We can also overload the `<<` operator to easily print `Complex` objects to the console. This is a common and powerful technique. The `<<` operator is typically overloaded as a non-member, non-friend function that takes an `ostream` reference and a `Complex` object reference as arguments. This allows you to use your custom class with the standard output stream (`std::cout`) just like you would with a built-in type. It's a great example of how operator overloading can make your custom classes seamlessly integrate with the C++ Standard Library.

#include <iostream>

class Vector2D {
private:
    double x;
    double y;

public:
    Vector2D(double newX = 0, double newY = 0) : x(newX), y(newY) {}

    // Overloading the + operator as a member function
    Vector2D operator+(const Vector2D& other) const {
        return Vector2D(x + other.x, y + other.y);
    }

    // Overloading the << operator as a non-member friend function
    friend std::ostream& operator<<(std::ostream& os, const Vector2D& v);
};

// Implementation of the overloaded << operator
std::ostream& operator<<(std::ostream& os, const Vector2D& v) {
    os << "(" << v.x << ", " << v.y << ")";
    return os;
}

int main() {
    Vector2D v1(1.0, 2.0);
    Vector2D v2(3.0, 4.0);

    Vector2D v3 = v1 + v2; // Calls the overloaded + operator

    std::cout << "Vector v1: " << v1 << std::endl;
    std::cout << "Vector v2: " << v2 << std::endl;
    std::cout << "Sum of v1 and v2: " << v3 << std::endl;

    return 0;
}

#include <iostream>

class Vector2D {
private:
    double x;
    double y;

public:
    Vector2D(double newX = 0, double newY = 0) : x(newX), y(newY) {}

    Vector2D operator+(const Vector2D& other) const {
        return Vector2D(x + other.x, y + other.y);
    }

    // New overloaded subtraction operator
    Vector2D operator-(const Vector2D& other) const {
        return Vector2D(x - other.x, y - other.y);
    }

    friend std::ostream& operator<<(std::ostream& os, const Vector2D& v);
};

std::ostream& operator<<(std::ostream& os, const Vector2D& v) {
    os << "(" << v.x << ", " << v.y << ")";
    return os;
}

int main() {
    Vector2D v1(5.0, 7.0);
    Vector2D v2(2.0, 3.0);

    Vector2D v_diff = v1 - v2; // Calls the overloaded - operator

    std::cout << "Vector v1: " << v1 << std::endl;
    std::cout << "Vector v2: " << v2 << std::endl;
    std::cout << "Difference of v1 and v2: " << v_diff << std::endl;

    return 0;
}

Lesson 1: Dynamic Memory Allocation

In our previous lessons, we've primarily worked with memory that is automatically managed for us, such as local variables on the stack. However, for many applications, especially those dealing with large datasets or objects whose size is not known at compile time, we need more control. This is where **dynamic memory allocation** comes in. Dynamic memory allocation is the process of allocating memory during program runtime from a region of memory known as the **heap** or **free store**. The size of this memory block can be determined at runtime, making it incredibly flexible. The heap is a large pool of memory that is available to the program as a whole, unlike the stack which is tied to the scope of a function call. This means that data allocated on the heap can persist even after the function that created it has finished executing, as long as you have a pointer to its memory address. This is a critical feature for building complex data structures like linked lists, trees, and dynamic arrays, where the number of elements can change during the program's execution.

In C++, we use the `new` and `delete` operators for dynamic memory allocation and deallocation. The `new` operator allocates memory on the heap for a specific data type and returns a pointer to the newly allocated block. For example, `int* ptr = new int;` allocates enough memory for a single integer and stores its address in the pointer `ptr`. You can then use the dereference operator (`*`) to access and modify the value at that address, as in `*ptr = 10;`. When you are finished using the dynamically allocated memory, it is your responsibility to release it back to the system using the `delete` operator, as in `delete ptr;`. This is a crucial step. Failing to deallocate memory when you are done with it is a common programming error known as a **memory leak**. A memory leak occurs when your program loses the ability to free a block of dynamically allocated memory. Over time, these leaks can consume all available memory, causing your program or even the entire system to crash. Therefore, every call to `new` should have a corresponding call to `delete`.

Working with Dynamic Arrays

One of the most common uses of dynamic memory allocation is creating arrays of a size that is determined at runtime. For example, if you wanted to read a list of numbers from a user, you wouldn't know the size of the array you need beforehand. You can use the `new` operator to create a dynamic array, for instance, `int* dynamicArray = new int[arraySize];`. After you are done with the array, you must use the special syntax `delete[]` to deallocate the entire block of memory, as in `delete[] dynamicArray;`. Using `delete` instead of `delete[]` on a dynamic array can lead to undefined behavior. This distinction is important because the runtime system needs to know if it's deallocating a single object or an array of objects. While dynamic memory allocation provides immense power, it also places the burden of memory management squarely on the programmer's shoulders. This is why modern C++ development often prefers to use a safer alternative, which we will discuss in our next lesson on smart pointers.

#include <iostream>

int main() {
    // Dynamic allocation of a single integer
    int* ptr = new int;
    *ptr = 42;
    std::cout << "Value of dynamically allocated integer: " << *ptr << std::endl;
    delete ptr; // Deallocate the memory

    // Dynamic allocation of an array
    int size;
    std::cout << "Enter the size of the dynamic array: ";
    std::cin >> size;

    int* dynamicArray = new int[size];
    for (int i = 0; i < size; ++i) {
        dynamicArray[i] = i * 10;
    }

    std::cout << "Values in the dynamic array: ";
    for (int i = 0; i < size; ++i) {
        std::cout << dynamicArray[i] << " ";
    }
    std::cout << std::endl;

    delete[] dynamicArray; // Deallocate the dynamic array
    dynamicArray = nullptr; // A good practice is to set the pointer to nullptr after deletion
    
    // Attempting to use a deleted pointer is a common error
    // std::cout << *ptr << std::endl; // This would lead to a segmentation fault

    return 0;
}

#include <iostream>

int main() {
    int numElements;
    std::cout << "Enter the number of integers: ";
    std::cin >> numElements;

    if (numElements <= 0) {
        std::cout << "Invalid number of elements." << std::endl;
        return 1;
    }

    int* numbers = new int[numElements];
    int sum = 0;

    std::cout << "Enter " << numElements << " integers:" << std::endl;
    for (int i = 0; i < numElements; ++i) {
        std::cin >> numbers[i];
        sum += numbers[i];
    }

    std::cout << "Sum of the numbers is: " << sum << std::endl;

    delete[] numbers;
    numbers = nullptr;

    return 0;
}

Lesson 2: Smart Pointers and RAII

In the previous lesson, we learned about dynamic memory allocation using `new` and `delete` and the potential pitfalls of memory leaks. Manually managing memory is error-prone, which is why modern C++ strongly advocates for a different approach: **smart pointers**. A smart pointer is a class that wraps a raw pointer, providing automatic memory management. It's essentially an object that behaves like a pointer but has an added benefit: when the smart pointer object goes out of scope, its destructor is automatically called, and the destructor then correctly deallocates the memory it points to. This design pattern, where a resource is tied to the lifetime of an object, is known as **Resource Acquisition Is Initialization (RAII)**. RAII is a fundamental concept in C++ that guarantees that resources are acquired and released correctly. It is the cornerstone of writing exception-safe code in C++, as resources are automatically cleaned up even if an exception is thrown. Smart pointers are the most prominent example of the RAII principle in action, and they are now the preferred way to handle dynamic memory in C++.

The C++ Standard Library provides three main types of smart pointers, each with a different ownership model:

• std::unique_ptr: This smart pointer provides **exclusive ownership** of the object it points to. A `unique_ptr` cannot be copied; it can only be moved. This guarantees that at any given time, only one `unique_ptr` can own the resource. When the `unique_ptr` goes out of scope, the memory is automatically deallocated. This is the most common and efficient smart pointer for single-owner scenarios.
• std::shared_ptr: This smart pointer provides **shared ownership**. Multiple `shared_ptr` objects can point to the same resource. The `shared_ptr` uses a reference count to keep track of how many pointers are currently pointing to the resource. The memory is deallocated only when the last `shared_ptr` that owns the resource is destroyed. This is ideal for situations where multiple parts of your program need to access and manage the same resource.
• std::weak_ptr: A `weak_ptr` is a smart pointer that holds a **non-owning reference** to an object managed by a `shared_ptr`. It does not increase the reference count of the `shared_ptr`. This is particularly useful for breaking circular references that can occur with `shared_ptr`s, which would otherwise prevent the memory from ever being deallocated. You can check if the object still exists by trying to create a `shared_ptr` from the `weak_ptr`. If the `shared_ptr`'s reference count is zero, the `weak_ptr` becomes "expired" and can't be used.

The shift to smart pointers has dramatically reduced the number of memory leaks and dangling pointer errors in C++ programs. They are an essential part of modern C++ programming and should be your go-to choice for dynamic memory management. By letting the compiler and the smart pointer's class handle the deallocation, you can focus on the logic of your program instead of the tedious and error-prone task of manual memory management. This leads to more robust, safer, and cleaner code.

#include <iostream>
#include <memory>

class Resource {
public:
    Resource() { std::cout << "Resource acquired." << std::endl; }
    ~Resource() { std::cout << "Resource destroyed." << std::endl; }
    void sayHi() { std::cout << "Hello from the resource." << std::endl; }
};

void processUniquePtr() {
    std::cout << "--- Unique Pointer Example ---" << std::endl;
    // Create a unique_ptr
    std::unique_ptr uniqueRes = std::make_unique();
    uniqueRes->sayHi();
    // unique_ptr cannot be copied
    // std::unique_ptr anotherUniqueRes = uniqueRes; // Compile error
} // uniqueRes goes out of scope here, destructor is called automatically

void processSharedPtr() {
    std::cout << "\n--- Shared Pointer Example ---" << std::endl;
    std::shared_ptr sharedRes1 = std::make_shared();
    {
        std::shared_ptr sharedRes2 = sharedRes1; // Reference count is now 2
        std::cout << "Reference count in inner scope: " << sharedRes1.use_count() << std::endl;
    } // sharedRes2 goes out of scope, reference count becomes 1
    std::cout << "Reference count in outer scope: " << sharedRes1.use_count() << std::endl;
} // sharedRes1 goes out of scope, reference count becomes 0, destructor is called

int main() {
    processUniquePtr();
    processSharedPtr();

    return 0;
}

#include <iostream>
#include <memory>

class Logger {
public:
    Logger() { std::cout << "Logger created." << std::endl; }
    ~Logger() { std::cout << "Logger destroyed." << std::endl; }
    void logMessage(const std::string& msg) {
        std::cout << "Logging: " << msg << std::endl;
    }
};

void processLogger(std::unique_ptr logger) {
    if (logger) {
        logger->logMessage("Processing with unique_ptr ownership.");
    }
}

int main() {
    // Shared pointer example
    std::shared_ptr sharedLogger = std::make_shared();
    std::cout << "Initial shared_ptr count: " << sharedLogger.use_count() << std::endl;

    {
        std::shared_ptr anotherSharedLogger = sharedLogger;
        std::cout << "Shared_ptr count inside block: " << sharedLogger.use_count() << std::endl;
    } // anotherSharedLogger goes out of scope

    std::cout << "Final shared_ptr count: " << sharedLogger.use_count() << std::endl;

    // Unique pointer example
    std::unique_ptr uniqueLogger = std::make_unique();
    processLogger(std::move(uniqueLogger)); // Ownership is moved to the function

    // After the move, uniqueLogger is now empty
    if (!uniqueLogger) {
        std::cout << "uniqueLogger is now empty after moving ownership." << std::endl;
    }
    
    // The logger is destroyed when processLogger() finishes
    return 0;
}

Lesson 3: Memory Leaks and Debugging

In the world of C++, particularly when dealing with dynamic memory, a key challenge is preventing and identifying memory leaks. A **memory leak** occurs when your program allocates memory on the heap but fails to deallocate it, making it inaccessible and unusable for the remainder of the program's execution. Over time, these unreleased memory blocks can accumulate, consuming all available system memory and causing performance degradation, program crashes, or even system-wide instability. Memory leaks are a notoriously difficult class of bugs to find because they often don't cause an immediate crash. Instead, their effects are gradual and can manifest as seemingly random failures long after the leaked memory was allocated. A common scenario for a memory leak is forgetting to call `delete` on a `new`'d pointer, especially in a function that has multiple exit points or within a loop where memory is repeatedly allocated without being freed.

To prevent memory leaks, the golden rule is simple: **every `new` must have a corresponding `delete`**. However, following this rule perfectly can be challenging, especially in complex applications. This is why the modern C++ approach of using **smart pointers** is so powerful. Smart pointers like `std::unique_ptr` and `std::shared_ptr` implement the RAII principle, automatically deallocating memory when they go out of scope. By using smart pointers, you can effectively eliminate a whole class of memory leak bugs, as the responsibility of memory deallocation is shifted from the programmer to the smart pointer's class. In legacy codebases or in situations where smart pointers might not be an option, you must be meticulous in your memory management. Tools like `valgrind` on Linux or the Memory Profiler in Visual Studio are invaluable for detecting memory leaks. These tools can analyze your program's memory usage during runtime and report any blocks of memory that were allocated but never freed. Learning how to use these debugging tools is an essential skill for any C++ developer, as it allows you to hunt down and fix memory-related issues that are otherwise invisible to the naked eye.

Common Causes and Debugging Techniques

One of the most common causes of memory leaks is forgetting to `delete[]` a dynamic array. A simple `delete` on an array of objects will only call the destructor for the first object, leaving the rest of the memory unreleased. Another common issue is losing the pointer to a dynamically allocated object. If a pointer variable goes out of scope without its memory being deallocated, the memory is leaked because you can no longer access the pointer to free it. This is why it's a good practice to set a pointer to `nullptr` after you have deleted the memory it points to. This prevents a **dangling pointer**, which is a pointer that points to a deallocated block of memory. Attempting to dereference a dangling pointer leads to undefined behavior and is a common cause of segmentation faults. When debugging, you should always start by looking for places where `new` and `delete` calls are not paired up. Pay close attention to loops and functions that allocate memory, and use a debugger to step through the code and monitor the value of your pointers. The ability to use debugging tools to trace memory allocation and deallocation is a critical skill that distinguishes a proficient C++ programmer.

#include <iostream>

void memoryLeakExample() {
    int* ptr = new int[100]; // Allocate an array of 100 integers
    // We forget to call `delete[] ptr` at the end of the function.
    // The memory is now leaked.
    std::cout << "Potential memory leak here." << std::endl;
} // 'ptr' goes out of scope, but the memory is not deallocated

void noLeakExample() {
    int* ptr = new int[100];
    // ... use the memory ...
    delete[] ptr; // Correctly deallocate the memory
    std::cout << "No memory leak here." << std::endl;
}

int main() {
    memoryLeakExample();
    noLeakExample();
    
    // Using smart pointers prevents leaks automatically
    std::unique_ptr safePtr = std::make_unique(100);
    std::cout << "Smart pointer takes care of deallocation automatically." << std::endl;

    return 0;
}

#include <iostream>

void buggyFunction(int size) {
    int* data = new int[size];
    // Fill the array with some values
    for (int i = 0; i < size; ++i) {
        data[i] = i * 2;
    }
    std::cout << "Data allocated. The first element is: " << data[0] << std::endl;

    // This is where the leak occurs. The memory is never freed.
    // To fix this, add `delete[] data;` here.
    delete[] data;
    data = nullptr;
}

int main() {
    buggyFunction(10);
    std::cout << "The program has finished. If the leak was fixed, memory is clean." << std::endl;
    return 0;
}

Lesson 4: Stack vs Heap Management

In C++, a program uses two primary regions of memory for data storage: the **stack** and the **heap**. Understanding the differences between these two is fundamental to writing efficient and robust programs. The **stack** is a contiguous block of memory used for local variables and function call frames. When a function is called, a new frame is "pushed" onto the stack, containing its local variables and other information. When the function returns, its frame is "popped" off the stack, and all the memory it used is automatically reclaimed. This process is very fast and efficient, as it is managed by the compiler and the CPU. Variables on the stack have a fixed size known at compile time, and their lifetime is tied directly to the scope in which they are declared. This makes stack allocation a great choice for small, short-lived variables like integers, booleans, or small objects. However, due to its fixed size and automatic nature, the stack is not suitable for large objects or data that needs to persist beyond a function's lifetime. The size of the stack is typically much smaller than the heap, so trying to allocate a large array on the stack can result in a "stack overflow" error.

The **heap** (also known as the free store) is a large, unstructured pool of memory that is used for **dynamic memory allocation**. This is the memory we interact with using `new` and `delete`. Unlike the stack, the heap is not managed automatically by the compiler. Memory on the heap is allocated at runtime, and its size can be determined dynamically. The lifetime of a heap-allocated object is not tied to a specific scope; it persists until you explicitly deallocate it using `delete`. This makes the heap perfect for storing large objects, data structures with a variable size (like dynamic arrays or vectors), and objects that need to be shared across different functions or persist for the entire duration of the program. However, allocating and deallocating memory on the heap is slower than on the stack, as it involves a more complex process to find and manage free blocks of memory. Furthermore, as we discussed in the previous lesson, managing heap memory manually with `new` and `delete` can be error-prone, leading to memory leaks or other memory-related bugs. This is a key reason why modern C++ development prefers smart pointers to manage heap memory automatically, combining the flexibility of the heap with the safety of stack-based resource management.

Key Differences and Best Practices

Here's a quick summary of the key differences:

• Stack: Fast allocation/deallocation, fixed size at compile time, automatic memory management, limited size. Best for local, short-lived variables.
• Heap: Slower allocation/deallocation, dynamic size at runtime, manual memory management (or smart pointers), large size. Best for large objects, dynamic data structures, and data that must persist.

#include <iostream>
#include <memory>

// Function to demonstrate stack allocation
void stackExample() {
    int stackVar = 10; // Allocated on the stack
    std::cout << "stackVar is on the stack: " << stackVar << std::endl;
} // stackVar is automatically deallocated here

// Function to demonstrate heap allocation
void heapExample() {
    int* heapPtr = new int; // Allocated on the heap
    *heapPtr = 20;
    std::cout << "heapPtr is a pointer on the stack, pointing to memory on the heap: " << *heapPtr << std::endl;
    delete heapPtr; // Manual deallocation
}

int main() {
    stackExample();
    heapExample();

    // Using a smart pointer for safer heap management
    std::unique_ptr safePtr = std::make_unique(30);
    std::cout << "safePtr is a smart pointer on the stack, managing heap memory: " << *safePtr << std::endl;

    return 0; // safePtr's destructor is called, deallocating the memory
}

#include <iostream>
#include <vector>

int main() {
    // Stack allocation for a fixed-size array
    int stackArray[5] = {1, 2, 3, 4, 5};
    std::cout << "Stack array elements: ";
    for (int i = 0; i < 5; ++i) {
        std::cout << stackArray[i] << " ";
    }
    std::cout << std::endl;

    // Heap allocation for a dynamic array (using a vector for safety)
    int size;
    std::cout << "Enter the size for the dynamic array (e.g., 10): ";
    std::cin >> size;

    if (size > 0) {
        // C++ vectors manage their own heap memory, a better alternative
        std::vector heapVector(size);
        for (int i = 0; i < size; ++i) {
            heapVector[i] = i * 10;
        }

        std::cout << "Heap vector elements: ";
        for (int value : heapVector) {
            std::cout << value << " ";
        }
        std::cout << std::endl;
    }

    return 0; // Vector's destructor automatically frees the heap memory
}

Lesson 5: Copy Constructors and Assignment

In C++, when you work with objects, you often need to create copies of them. This can happen when you pass an object by value to a function, return an object by value, or explicitly assign one object to another. To handle these situations correctly, C++ provides two special member functions: the **copy constructor** and the **copy assignment operator**. A copy constructor is a special constructor that is called when a new object is created as a copy of an existing object. Its signature is `ClassName(const ClassName& other)`. The `const` keyword ensures that the original object is not modified, and the reference (`&`) avoids an infinite loop of copy constructor calls. By default, C++ provides a shallow, member-wise copy constructor. This works fine for classes with no dynamically allocated members. However, for classes that manage their own dynamic memory (e.g., a custom dynamic array class), the default copy constructor can be disastrous. It would simply copy the pointer, leading to two objects pointing to the same memory. When one object is destroyed, the memory is freed, and the other object is left with a **dangling pointer**, which can lead to a crash. This is a classic example of when you need to write your own copy constructor to perform a **deep copy**, which involves allocating new memory and copying the contents of the original object into the new memory.

The **copy assignment operator** (operator=) is another special member function that is called when an existing object is assigned the value of another existing object. Its signature is typically `ClassName& operator=(const ClassName& other)`. Like the copy constructor, C++ provides a default shallow copy assignment operator. You must also implement your own deep-copy assignment operator for classes with dynamic memory. A deep copy implementation for the assignment operator should follow a standard pattern to handle self-assignment (e.g., `obj = obj;`) and to ensure that memory is correctly deallocated and then reallocated. The common idiom for the copy assignment operator is the **copy-and-swap idiom**, which is a powerful technique that simplifies the code and provides strong exception safety guarantees. This idiom involves creating a copy of the source object, swapping the contents of the current object with the copy, and then letting the temporary copy's destructor handle the deallocation of the old memory. This approach is not only cleaner but also safer in the face of exceptions.

The Rule of Three/Five/Zero

The concepts of copy constructors and copy assignment operators are part of a larger set of rules in C++ known as the **Rule of Three/Five/Zero**. The **Rule of Three** states that if you define any of the following, you should define all three: a destructor, a copy constructor, and a copy assignment operator. The reason is that if your class needs a custom implementation for one of these, it's highly likely it needs custom implementations for all of them to handle deep copying and memory management correctly. With the introduction of move semantics in C++11, this rule was extended to the **Rule of Five**, which also includes the move constructor and move assignment operator. The **Rule of Zero** is a modern C++ guideline that suggests you should avoid manually managing memory in your classes altogether by using smart pointers and containers from the standard library. By following the Rule of Zero, you don't need to define any of these special member functions, as the standard library components will handle memory management for you, making your code safer and simpler. The Rule of Zero is a powerful concept that pushes you towards writing more robust, modern C++.

#include <iostream>

class MyArray {
private:
    int* data;
    int size;

public:
    // Parameterized constructor
    MyArray(int s) : size(s) {
        data = new int[size];
        std::cout << "Constructor called. Memory allocated at " << data << std::endl;
    }

    // Copy constructor (deep copy)
    MyArray(const MyArray& other) : size(other.size) {
        data = new int[size];
        for (int i = 0; i < size; ++i) {
            data[i] = other.data[i];
        }
        std::cout << "Copy constructor called (deep copy). New memory at " << data << std::endl;
    }

    // Copy assignment operator (deep copy)
    MyArray& operator=(const MyArray& other) {
        if (this != &other) { // Handle self-assignment
            delete[] data; // Deallocate old memory
            size = other.size;
            data = new int[size]; // Allocate new memory
            for (int i = 0; i < size; ++i) {
                data[i] = other.data[i]; // Copy data
            }
        }
        std::cout << "Copy assignment operator called." << std::endl;
        return *this;
    }

    // Destructor
    ~MyArray() {
        delete[] data;
        std::cout << "Destructor called. Memory at " << data << " deallocated." << std::endl;
    }
};

int main() {
    MyArray arr1(5);
    MyArray arr2 = arr1; // Calls the copy constructor
    MyArray arr3(10);
    arr3 = arr1; // Calls the copy assignment operator

    return 0;
}

#include <iostream>
#include <cstring>

class MyString {
private:
    char* data;
    size_t length;
public:
    MyString(const char* str = "") {
        length = strlen(str);
        data = new char[length + 1];
        strcpy(data, str);
        std::cout << "Constructor called for: " << data << std::endl;
    }

    MyString(const MyString& other) {
        length = other.length;
        data = new char[length + 1];
        strcpy(data, other.data);
        std::cout << "Copy constructor called for: " << data << std::endl;
    }

    ~MyString() {
        delete[] data;
        std::cout << "Destructor called for: " << data << std::endl;
    }
};

int main() {
    MyString s1("Hello");
    MyString s2 = s1; // Calls the copy constructor
    return 0;
}

Lesson 1: Templates and Generic Programming

In this module, we will explore some of the more advanced and powerful features of C++, starting with **templates**. Templates are a powerful tool for **generic programming**, which is a style of programming that allows you to write code that works with a variety of data types without having to rewrite the code for each type. Imagine you need a function to find the maximum of two numbers. You could write one for `int`, another for `double`, and another for `float`. With templates, you can write a single, generic `max` function that works with any data type. This saves you from writing redundant code and makes your programs more flexible and maintainable. Templates are a compile-time feature; the compiler generates the specific code for each data type you use, a process known as **template instantiation**. This means that a template is not a function itself, but a blueprint for generating functions or classes. The compiler handles the generation of the specific code, and this is why you must provide the template definition (the implementation) in the header file for it to be accessible to other source files.

C++ has two main types of templates: **function templates** and **class templates**. A function template allows you to define a function that operates on generic types. You define a function template with the `template ` or `template ` syntax before the function signature. `T` is a placeholder for a data type that the compiler will fill in later. For example, a function template for `max` would look like `template T max(T a, T b) { ... }`. When you call `max(5, 10)`, the compiler deduces that `T` should be `int` and generates a `max` function for integers. When you call `max(3.14, 2.71)`, it generates one for doubles. A **class template** allows you to define a class with generic types. A great example is the `std::vector` class from the Standard Template Library (STL). A `std::vector` is an instance of the vector class template with the type `T` set to `int`. You can create a vector of any data type, and the class template will generate the necessary code to manage that type. This generic nature is what makes the STL so incredibly versatile and useful.

Benefits and Considerations

Templates offer significant benefits, including code reuse, type safety, and performance. Because the code is generated at compile time, there is no runtime overhead associated with generic programming in C++, unlike in some other languages. The compiler also performs type checking, ensuring that the types used with the template are compatible with the operations performed inside the template. However, there are some complexities to be aware of. Template code can sometimes be harder to debug because the errors can be quite verbose and cryptic, as they show the generated code. Another consideration is code bloat, which is the possibility of the compiler generating a large amount of code if a template is instantiated with many different types. Modern C++ compilers are quite good at mitigating this, but it's still a factor to consider in large-scale applications. Despite these challenges, templates are an indispensable tool for any serious C++ developer. They are the foundation of the C++ Standard Library and a key to writing clean, efficient, and reusable code.

#include <iostream>
#include <string>

// A function template to find the maximum of two values
template 
T maximum(T a, T b) {
    return (a > b) ? a : b;
}

// A class template for a simple container
template 
class Container {
private:
    T value;
public:
    Container(T val) : value(val) {}
    T getValue() const {
        return value;
    }
};

int main() {
    int maxInt = maximum(10, 5);
    std::cout << "Maximum of 10 and 5 is: " << maxInt << std::endl;

    double maxDouble = maximum(3.14, 2.71);
    std::cout << "Maximum of 3.14 and 2.71 is: " << maxDouble << std::endl;

    std::string str1 = "Hello";
    std::string str2 = "World";
    std::string maxStr = maximum(str1, str2);
    std::cout << "Maximum of 'Hello' and 'World' is: " << maxStr << std::endl;
    
    Container intContainer(123);
    std::cout << "Value in int container: " << intContainer.getValue() << std::endl;
    
    Container stringContainer("Template Magic");
    std::cout << "Value in string container: " << stringContainer.getValue() << std::endl;

    return 0;
}

#include <iostream>

template 
void swapValues(T& a, T& b) {
    T temp = a;
    a = b;
    b = temp;
}

int main() {
    int x = 5, y = 10;
    std::cout << "Before swap: x = " << x << ", y = " << y << std::endl;
    swapValues(x, y);
    std::cout << "After swap: x = " << x << ", y = " << y << std::endl;

    double d1 = 3.14, d2 = 2.71;
    std::cout << "Before swap: d1 = " << d1 << ", d2 = " << d2 << std::endl;
    swapValues(d1, d2);
    std::cout << "After swap: d1 = " << d1 << ", d2 = " << d2 << std::endl;

    return 0;
}

Lesson 2: STL (Standard Template Library)

The **Standard Template Library (STL)** is a collection of C++ templates that provides a set of common data structures and algorithms. It is a cornerstone of modern C++ development and is an invaluable tool for any programmer. The STL is comprised of four main components: **containers**, **iterators**, **algorithms**, and **functors**. Containers are data structures like dynamic arrays (`vector`), lists (`list`), maps (`map`), and sets (`set`) that can hold objects of any data type. Iterators are objects that allow you to traverse through the elements of a container, providing a generalized way to access elements regardless of the container type. Algorithms are a collection of functions that perform common operations on containers, such as searching, sorting, and transforming. Functors are objects that can be called like functions, often used with algorithms to customize their behavior. The STL's power lies in its interoperability: iterators provide a consistent interface for algorithms to work with all types of containers, allowing you to mix and match them as needed. Mastering the STL is a key milestone for any C++ programmer, as it drastically reduces development time and improves code quality by providing highly optimized, tested, and reliable components.

Let's take a closer look at the key components:

• Containers:
  • `std::vector` (Dynamic Array): A dynamic array that can grow or shrink in size. It provides fast random access to elements. It is the most commonly used container.
  • `std::list` (Doubly Linked List): A container that allows for fast insertion and deletion of elements anywhere in the list. However, it does not provide fast random access.
  • `std::map` (Associative Array): Stores key-value pairs, where the keys are unique and sorted. It provides fast lookups based on the key.
  • `std::set` (Set): A container that stores unique, sorted elements. It's useful for checking for the existence of an element.
• Iterators: An iterator is an object that points to an element in a container. They are used to navigate through containers. For example, `std::vector::iterator` is the iterator for a vector. You can use operators like `++` to move to the next element and `*` to dereference the iterator and access the element's value.
• Algorithms: The `` header provides a vast collection of algorithms. Some common examples include:
  • `std::sort()`: Sorts the elements in a range.
  • `std::find()`: Searches for a specific value in a range.
  • `std::for_each()`: Applies a function or functor to each element in a range.

The beauty of the STL is that you can use the same algorithms with different containers. For example, `std::sort()` can sort a `std::vector` or a `std::list` (though `std::list` has its own `sort()` method for efficiency). This decoupling of data structures from algorithms is a powerful design principle that makes the STL so flexible. When you are faced with a programming problem, your first thought should always be, "Is there an STL component that can help me with this?" This mindset will lead to cleaner, more efficient, and more reliable code. The STL is a vast library, and while we've only touched on the basics, getting a good grasp of it is a significant step towards becoming a proficient C++ programmer.

#include <iostream>
#include <vector>
#include <algorithm>
#include <string>

int main() {
    // Using a std::vector container
    std::vector numbers = {5, 2, 8, 1, 9};

    // Using an iterator to print elements
    std::cout << "Original vector elements: ";
    for (std::vector::iterator it = numbers.begin(); it != numbers.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    // Using an algorithm: std::sort()
    std::sort(numbers.begin(), numbers.end());
    std::cout << "Sorted vector elements: ";
    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    // Using another algorithm: std::find()
    auto it = std::find(numbers.begin(), numbers.end(), 8);
    if (it != numbers.end()) {
        std::cout << "Found number 8 at index: " << std::distance(numbers.begin(), it) << std::endl;
    } else {
        std::cout << "Number 8 not found." << std::endl;
    }

    return 0;
}

#include <iostream>
#include <map>
#include <string>

int main() {
    std::map countryPopulations;

    countryPopulations["China"] = 1441000000;
    countryPopulations["India"] = 1393000000;
    countryPopulations["USA"] = 331000000;

    std::string country;
    std::cout << "Enter a country name to get its population: ";
    std::cin >> country;

    auto it = countryPopulations.find(country);
    if (it != countryPopulations.end()) {
        std::cout << "The population of " << it->first << " is: " << it->second << std::endl;
    } else {
        std::cout << "Country not found in the map." << std::endl;
    }

    return 0;
}

Lesson 3: Exception Handling

In the real world, programs don't always run perfectly. Errors, or **exceptions**, can occur at runtime due to various reasons, such as invalid user input, file not found errors, or network connection failures. When an exception occurs, it can lead to program termination, a crash, or an unpredictable state. **Exception handling** in C++ is a mechanism that allows you to gracefully deal with these runtime errors. Instead of crashing, your program can "catch" the exception and execute a specific block of code to handle it. This prevents the program from terminating abruptly and allows you to recover from the error in a controlled manner. Exception handling is a vital component of writing robust and reliable software. It separates the code that deals with "normal" program flow from the code that deals with "exceptional" or error conditions, leading to cleaner and more readable code.

The C++ exception handling mechanism is based on three keywords: `try`, `throw`, and `catch`.

• `try` block: This is a block of code that you want to monitor for exceptions. If an exception occurs within a `try` block, the program's control is immediately transferred to the corresponding `catch` block.
• `throw` statement: When an exceptional condition is detected, you can `throw` an exception. The `throw` statement can be used to throw an object of any data type, but it's a best practice to throw objects that derive from `std::exception` or its subclasses, as they provide a standard way to convey error information.
• `catch` block: This is a block of code that is executed when an exception is thrown in its associated `try` block. A `catch` block specifies the type of exception it can handle. You can have multiple `catch` blocks to handle different types of exceptions, and a generic `catch(...)` block can be used to catch any type of exception.

A well-designed exception handling strategy is crucial for building resilient applications. It allows you to centralize your error handling logic, ensuring that all resources are properly cleaned up even when an exception is thrown. This is where the RAII principle, which we learned about in the memory management module, truly shines. The destructors of objects on the stack are guaranteed to be called during an exception unwind, which means that smart pointers and other RAII-compliant objects will automatically release their resources, preventing resource leaks. This makes C++ exception handling a very powerful and safe mechanism when used correctly. Without proper exception handling, a single unexpected error can bring down your entire application, so understanding and implementing it is a critical skill for any C++ developer.

#include <iostream>
#include <string>
#include <stdexcept>

double divide(double numerator, double denominator) {
    if (denominator == 0) {
        throw std::runtime_error("Division by zero is not allowed.");
    }
    return numerator / denominator;
}

int main() {
    double x = 10.0;
    double y = 0.0;
    double result;

    try {
        result = divide(x, y);
        std::cout << "Result: " << result << std::endl;
    }
    catch (const std::runtime_error& e) {
        std::cerr << "Caught an exception: " << e.what() << std::endl;
    }
    catch (...) {
        std::cerr << "Caught an unknown exception." << std::endl;
    }

    std::cout << "Program continues after exception handling." << std::endl;

    return 0;
}

#include <iostream>
#include <string>
#include <stdexcept>

void checkAge(int age) {
    if (age < 0) {
        throw std::out_of_range("Age cannot be negative.");
    }
    std::cout << "Age is valid: " << age << std::endl;
}

int main() {
    int userAge;
    std::cout << "Enter your age: ";
    std::cin >> userAge;

    try {
        checkAge(userAge);
    }
    catch (const std::out_of_range& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }
    catch (...) {
        std::cerr << "An unexpected error occurred." << std::endl;
    }

    return 0;
}

Lesson 4: File I/O and Streams

Most programs need to interact with the outside world, and one of the most common ways to do this is by reading from and writing to files. **File I/O (Input/Output)** in C++ is handled through a powerful and consistent mechanism called **streams**. A stream is an abstraction of a sequence of bytes. The C++ Standard Library provides various stream classes that allow you to read data from a file (input stream) and write data to a file (output stream). The beauty of this stream-based approach is that the same operators you use for console I/O, like `>>` (extraction) and `<<` (insertion), can be used for file I/O. This provides a uniform interface for handling data, whether it's coming from the keyboard, a file, or another source. Mastering file I/O is crucial for any application that needs to save data, load configurations, or interact with persistent storage.

The main stream classes for file I/O are found in the `` header:

• `std::ofstream` (Output File Stream): Used to write data to a file. You can create an `ofstream` object and open a file for writing. The `<<` operator is used to write data to the file, and the file is automatically closed when the `ofstream` object goes out of scope (thanks to the RAII principle).
• `std::ifstream` (Input File Stream): Used to read data from a file. You create an `ifstream` object and open a file for reading. The `>>` operator is used to read data from the file, and like `ofstream`, the file is closed automatically.
• `std::fstream` (File Stream): A versatile class that can be used for both reading from and writing to a file. You can open a file in different modes, such as input, output, or both.

Before you can perform any operations, you must open a file. The `open()` method is used for this, and it's a good practice to check if the file was opened successfully to avoid errors. The file can be opened in different **modes**, such as `ios::out` for writing, `ios::in` for reading, `ios::app` for appending to the end of a file, and `ios::binary` for handling binary files. The ability to specify these modes gives you fine-grained control over how you interact with files. After you have finished with a file, you can explicitly close it using the `close()` method, although it will be closed automatically when the stream object is destroyed. In a real-world application, it is also important to handle potential errors, such as a file not being found or a disk full error. You can check the state of the stream using functions like `is_open()`, `good()`, `fail()`, and `eof()` to ensure that your file operations are proceeding as expected. By mastering these concepts, you'll be able to create applications that can store and retrieve data, making them much more useful and powerful.

#include <iostream>
#include <fstream>
#include <string>

int main() {
    // Write to a file
    std::ofstream outputFile("output.txt");
    if (outputFile.is_open()) {
        outputFile << "Hello, this is a line of text." << std::endl;
        outputFile << "This is another line." << std::endl;
        outputFile.close();
        std::cout << "Data successfully written to output.txt" << std::endl;
    } else {
        std::cerr << "Error opening file for writing!" << std::endl;
    }

    // Read from a file
    std::ifstream inputFile("output.txt");
    if (inputFile.is_open()) {
        std::string line;
        std::cout << "Reading from output.txt:" << std::endl;
        while (std::getline(inputFile, line)) {
            std::cout << line << std::endl;
        }
        inputFile.close();
    } else {
        std::cerr << "Error opening file for reading!" << std::endl;
    }

    return 0;
}

#include <iostream>
#include <fstream>
#include <string>

int main() {
    std::ofstream logFile("log.txt", std::ios::app); // Open in append mode
    if (!logFile.is_open()) {
        std::cerr << "Error opening log file!" << std::endl;
        return 1;
    }

    std::string userInput;
    std::cout << "Enter text to log (type 'quit' to exit):" << std::endl;

    while (std::getline(std::cin, userInput) && userInput != "quit") {
        logFile << userInput << std::endl;
    }

    logFile.close();
    std::cout << "Logging complete. The log file is ready." << std::endl;

    return 0;
}

Lesson 5: Multithreading and Concurrency

In the final lesson of this module, we will explore **multithreading** and **concurrency**, a topic that has become increasingly important with the rise of multi-core processors. **Multithreading** is the ability of a program to execute multiple threads of control concurrently. A thread is the smallest unit of execution within a process. A single-threaded program executes one instruction after another, while a multithreaded program can execute multiple instructions at the same time, giving the illusion of parallel execution. This is especially useful for tasks that can be broken down into independent sub-tasks, such as processing a large dataset, handling user interface events while performing background computations, or making multiple network requests simultaneously. By leveraging the power of multiple cores, multithreading can significantly improve the performance and responsiveness of your applications.

The C++11 standard introduced a robust library for multithreading, found in the `` header. The `std::thread` class is the primary tool for creating and managing threads. To create a new thread, you simply instantiate a `std::thread` object and pass it the function you want to execute in the new thread. For example, `std::thread myThread(myFunction, arg1, arg2);` creates a new thread that will execute `myFunction` with the given arguments. Once a thread has been created, you must either **join** or **detach** it. `myThread.join()` causes the main thread to wait for `myThread` to finish its execution before continuing. This is a common and safe way to ensure that all threads have completed their work. `myThread.detach()` allows the thread to run independently in the background. If you don't join or detach a thread before its `std::thread` object is destroyed, it can lead to program termination, so this is a critical detail to remember. The state of a thread is managed by the `std::thread` object, and you can't create a `std::thread` object without providing a function to execute, which is a good design choice that prevents you from having an uninitialized thread object.

The Challenges of Concurrency

While multithreading offers great benefits, it also introduces new challenges, primarily related to **concurrency** and **race conditions**. A race condition occurs when two or more threads access shared data and try to change it at the same time. The final result depends on the order of execution, which is non-deterministic and can lead to unexpected and often difficult-to-reproduce bugs. To prevent race conditions, you need to use synchronization mechanisms. The C++ Standard Library provides several tools for this, including:

• `std::mutex` (Mutual Exclusion): A `mutex` is a lock that ensures only one thread can access a shared resource at a time. A thread locks the mutex before accessing the shared data and unlocks it when it's done. A `std::lock_guard` or `std::unique_lock` is a great RAII-compliant way to manage a mutex, ensuring it is always unlocked even if an exception is thrown.
• `std::atomic` (Atomic Operations): The `` header provides a set of classes for performing atomic operations on data types. An atomic operation is one that is guaranteed to be performed as a single, indivisible unit, preventing other threads from interfering. This is a very efficient way to handle simple shared variables, as it avoids the overhead of a mutex.

Understanding and correctly implementing these synchronization mechanisms is crucial for writing safe and reliable concurrent programs. Incorrect use of mutexes can lead to **deadlocks**, where two or more threads are waiting for each other to release a resource, and the program halts indefinitely. Multithreading is a complex topic, but with the right tools and a careful approach, you can harness its power to build high-performance applications. The C++ standard library provides a solid foundation for this, and we will explore these concepts in the code examples below.

#include <iostream>
#include <thread>
#include <vector>
#include <mutex>
#include <chrono>

std::mutex mtx; // Global mutex

void workerFunction(int id) {
    // Lock the mutex to ensure exclusive access to std::cout
    std::lock_guard lock(mtx);
    std::cout << "Thread " << id << " is running." << std::endl;
}

int main() {
    std::vector threads;

    std::cout << "Launching 5 threads..." << std::endl;
    for (int i = 0; i < 5; ++i) {
        // Create a new thread and pass the worker function and a unique ID
        threads.emplace_back(workerFunction, i);
    }

    // Join all threads to wait for them to finish
    std::cout << "Main thread waiting for worker threads to finish..." << std::endl;
    for (auto& t : threads) {
        t.join();
    }
    std::cout << "All threads have finished." << std::endl;

    return 0;
}

#include <iostream>
#include <thread>
#include <vector>
#include <mutex>

const int NUM_THREADS = 10;
const int INCREMENTS_PER_THREAD = 100000;
long long counter = 0;
std::mutex mtx;

void incrementer_thread() {
    for (int i = 0; i < INCREMENTS_PER_THREAD; ++i) {
        // Use a mutex to protect the shared variable
        mtx.lock();
        counter++;
        mtx.unlock();
    }
}

int main() {
    std::vector threads;
    for (int i = 0; i < NUM_THREADS; ++i) {
        threads.emplace_back(incrementer_thread);
    }

    for (auto& t : threads) {
        t.join();
    }

    std::cout << "Final counter value: " << counter << std::endl;
    std::cout << "Expected value: " << (long long)NUM_THREADS * INCREMENTS_PER_THREAD << std::endl;

    return 0;
}

Lesson 1: C++11/14/17/20 Features

The C++ language has been evolving rapidly over the last decade, with major updates released in 2011, 2014, 2017, and 2020. These new standards, often referred to as **Modern C++**, have introduced a wealth of new features and improvements that make the language safer, more expressive, and more productive. Moving from the C++98 standard to C++11 was a monumental shift that brought about many of the features we now consider essential, such as smart pointers, move semantics, and lambdas. The subsequent standards, C++14, C++17, and C++20, continued this trend by adding even more powerful tools and refining existing ones. Embracing Modern C++ is not just about using the latest features; it's about adopting a new style of programming that is less error-prone and more focused on expressing intent clearly. Many of the features we've discussed, such as `std::unique_ptr`, `std::shared_ptr`, and `std::thread`, were all introduced in C++11. In this lesson, we'll take a look at some of the other key features from these modern standards that you should be aware of. Using these features will make your code more concise, safer, and easier to maintain.

Some of the most impactful features from Modern C++ include:

• `auto` keyword (C++11): The `auto` keyword allows the compiler to deduce the type of a variable from its initializer. This reduces boilerplate code and makes it easier to work with complex types, especially from the STL. For example, `auto iter = myVector.begin();` is much cleaner than `std::vector::iterator iter = myVector.begin();`.
• Range-based `for` loop (C++11): This new type of `for` loop simplifies iterating over containers and arrays. Instead of managing iterators or indices, you can simply write `for (const auto& element : container) { ... }`. This makes your loops more readable and less prone to off-by-one errors.
• Lambda expressions (C++11): Lambda expressions allow you to create anonymous functions (functions without a name) on the fly. They are incredibly useful for providing a quick, in-place function for algorithms like `std::sort` or `std::for_each`, which often need a custom comparison or operation.
• Move semantics (C++11): This feature provides a way to transfer ownership of a resource from one object to another without performing a costly deep copy. It is implemented through the `std::move` function and move constructors/assignment operators and is a cornerstone of smart pointers and efficient resource management.
• `std::optional`, `std::variant`, `std::any` (C++17): These new utility classes provide safer and more expressive ways to handle optional values (`std::optional`), store a value that can be one of several types (`std::variant`), or hold any type of value (`std::any`). They are a significant improvement over using raw pointers or unions for these purposes.
• Concepts (C++20): Concepts provide a way to constrain template parameters, making template error messages much more readable and helping you enforce design choices at compile time. They allow you to specify the requirements that a type must meet to be used with a template, which is a major step forward for template metaprogramming.

Learning these features is essential for staying current with C++ and for writing high-quality, modern code. The adoption of these standards has transformed C++ into a language that is not only fast and powerful but also much more pleasant to use. The transition to Modern C++ has made the language more expressive, safer, and more productive, bringing it in line with many of the features found in other modern languages while retaining its unique strengths. The image below shows a quick overview of some C++11 features.

#include <iostream>
#include <vector>
#include <numeric>
#include <algorithm>
#include <string>

int main() {
    std::vector numbers = {1, 2, 3, 4, 5};

    // C++11: Range-based for loop with auto
    std::cout << "Vector elements (using range-based for loop): ";
    for (auto num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    // C++11: Lambda expression with std::for_each
    std::cout << "Vector elements doubled: ";
    std::for_each(numbers.begin(), numbers.end(), [](int& n) {
        n *= 2;
        std::cout << n << " ";
    });
    std::cout << std::endl;

    // C++17: std::optional
    std::optional maybeName;
    if (std::rand() % 2 == 0) {
        maybeName = "Alice";
    }

    if (maybeName) {
        std::cout << "Name is set to: " << *maybeName << std::endl;
    } else {
        std::cout << "Name is not set." << std::endl;
    }

    return 0;
}

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

void toUpper(std::string& s) {
    for (char& c : s) {
        c = toupper(c);
    }
}

int main() {
    std::vector words = {"hello", "world", "ready", "ht"};

    std::cout << "Original words: ";
    for (const auto& word : words) {
        std::cout << word << " ";
    }
    std::cout << std::endl;

    std::for_each(words.begin(), words.end(), [](std::string& s) {
        for (char& c : s) {
            c = toupper(c);
        }
    });

    std::cout << "Uppercase words: ";
    for (const auto& word : words) {
        std::cout << word << " ";
    }
    std::cout << std::endl;

    return 0;
}

Lesson 2: Lambda Expressions and Auto

In the previous lesson, we briefly introduced **lambda expressions** and the `auto` keyword as key features of Modern C++. Now, we'll take a deeper dive into these powerful tools. A **lambda expression** is a concise way to create an anonymous function object, often used for a one-off operation. It allows you to define a function right where you need it, which is incredibly useful for algorithms in the STL like `sort`, `for_each`, and `find_if`. A lambda expression has a unique syntax, starting with a **capture clause** (`[]`), followed by a parameter list (`()`), and a function body (`{}`). The capture clause is a powerful part of the lambda, as it specifies which variables from the enclosing scope the lambda can access. You can capture variables by value (`[variable]`), by reference (`[&variable]`), or all local variables by value (`[=]`) or reference (`[&]`). The flexibility of lambdas allows you to write highly expressive and compact code, making complex operations feel much more natural and readable. They are a game-changer for C++ programming, as they reduce the need for writing small, one-time helper functions or using clumsy function pointers.

The **`auto` keyword**, introduced in C++11, is another feature that dramatically improves code clarity and reduces verbosity. The `auto` keyword tells the compiler to automatically deduce the type of a variable from its initializer. This is particularly useful when working with complex types from the STL or when the type is long and unwieldy, such as an iterator. For example, instead of writing `std::vector::const_iterator it = myVector.cbegin();`, you can simply write `auto it = myVector.cbegin();`. The compiler will figure out the type for you. This not only makes your code shorter and easier to read but also helps prevent errors, as the compiler can't get the type wrong. The `auto` keyword is a tool for expressing your intent clearly and letting the compiler handle the details. It is important to note that `auto` is not a `variant` or a `template` parameter. The type is deduced at compile time, and once a variable is declared with `auto`, its type is fixed and cannot change. This ensures that C++ remains a strongly-typed language even with the use of `auto`. The combination of `auto` and lambdas is a staple of modern C++ programming, allowing you to write code that is both powerful and elegant.

Practical Application and Best Practices

A common use case for lambdas is with the `std::sort` algorithm. Instead of writing a separate comparison function, you can provide a lambda directly to `std::sort` to define a custom sorting order. For example, to sort a vector of pairs based on the second element, you can use a lambda that captures nothing and takes two pairs as arguments. Similarly, `auto` is best used when the type is obvious from the context, or when the type is complex and verbose. Using `auto` for simple types like `int` might sometimes make the code less readable, so it's a matter of judgment. The combination of these two features allows for a functional programming style within C++, where you can chain together algorithms and lambdas to create complex data transformations in a clear and expressive way. The ability to express intent so directly is one of the biggest reasons to adopt these modern C++ features. They are not just syntactic sugar; they are powerful tools that change the way you approach programming in C++.

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector nums = {5, 2, 8, 1, 9};

    // Using auto for type deduction and a lambda for sorting
    auto sortPredicate = [](int a, int b) {
        return a > b;
    };
    std::sort(nums.begin(), nums.end(), sortPredicate);

    std::cout << "Sorted numbers (descending): ";
    // Using a range-based for loop with auto
    for (auto& n : nums) {
        std::cout << n << " ";
    }
    std::cout << std::endl;

    // Using a lambda with a capture clause
    int a = 10;
    auto findPredicate = [a](int x) {
        return x > a;
    };
    auto it = std::find_if(nums.begin(), nums.end(), findPredicate);
    if (it != nums.end()) {
        std::cout << "First number greater than " << a << " is: " << *it << std::endl;
    }

    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int evenCount = 0;

    std::cout << "Even numbers in the vector: ";
    std::for_each(numbers.begin(), numbers.end(), [&evenCount](int n) {
        if (n % 2 == 0) {
            std::cout << n << " ";
            evenCount++;
        }
    });
    std::cout << std::endl;
    
    std::cout << "Total even numbers found: " << evenCount << std::endl;

    return 0;
}

Lesson 3: Game Development Basics

One of the most popular and demanding applications for C++ is **game development**. The language's high performance, low-level memory control, and ability to handle large, complex systems make it an ideal choice for building high-end video games. Many of the most popular game engines, such as Unreal Engine and a significant part of Unity, are built on C++. While building a complete game is a massive undertaking, understanding the basics of how C++ is used in game development is an excellent way to apply your knowledge and see the language's power in action. At a high level, a game engine is a software framework that handles a variety of tasks, including rendering graphics, processing physics, handling user input, managing sound, and much more. Your game code, written in C++, interacts with the engine through its API to create game objects, define their behavior, and control the game's logic. This lesson will provide you with a brief overview of the key concepts and technologies used in C++ game development, giving you a taste of what it's like to build an interactive world.

At the core of any game is a **game loop**. This is an infinite loop that runs for the entire duration of the game. Inside the loop, a few key things happen in a specific order:

• Input Processing: The game checks for user input from the keyboard, mouse, or other controllers.
• Updating Game State: This is where the game's logic lives. It updates the positions of objects, checks for collisions, and manages the game's rules. This is often where you'll use C++'s object-oriented features to represent game entities like characters, enemies, and power-ups.
• Rendering: The game draws the updated state to the screen. This involves using a graphics API like OpenGL or DirectX to send commands to the GPU to render 2D or 3D graphics. This is where C++'s performance is critical, as you need to render thousands or even millions of polygons at a high frame rate.

To make this happen, C++ game developers often use a variety of libraries and tools. For 2D graphics and input, libraries like SFML or SDL are popular choices. For 3D graphics, you would typically use a graphics API wrapper library like the ones built into the Unreal Engine. C++'s object-oriented nature is perfectly suited for representing game objects. You might have a base class `GameObject` with virtual functions for `update()` and `draw()`, and then derived classes like `Player`, `Enemy`, and `PowerUp` that provide their own specific implementations. This is a classic example of polymorphism in action. Understanding these foundational concepts is the first step towards building your own games in C++. Even a simple game like a "Pong" clone can be an incredibly rewarding project that teaches you a lot about the core principles of game development, such as collision detection, state management, and real-time rendering. The image below shows a simple C++ game development architecture.

#include <iostream>
#include <chrono>
#include <thread>
#include <string>
#include <vector>

// A simple game object base class
class GameObject {
public:
    virtual void update() = 0;
    virtual void render() = 0;
};

// Player object
class Player : public GameObject {
private:
    int x, y;
public:
    Player() : x(0), y(0) {}
    void update() override {
        // Simulate player movement
        x++;
        y++;
    }
    void render() override {
        std::cout << "Player rendered at (" << x << ", " << y << ")" << std::endl;
    }
};

// The main game loop
void gameLoop(std::vector& objects) {
    auto lastFrameTime = std::chrono::high_resolution_clock::now();
    
    for(int i = 0; i < 5; ++i) { // Run for 5 frames for this example
        auto currentFrameTime = std::chrono::high_resolution_clock::now();
        std::chrono::duration deltaTime = currentFrameTime - lastFrameTime;
        lastFrameTime = currentFrameTime;

        std::cout << "--- Frame " << i+1 << " ---" << std::endl;

        // Update all game objects
        for (auto obj : objects) {
            obj->update();
        }

        // Render all game objects
        for (auto obj : objects) {
            obj->render();
        }
        std::this_thread::sleep_for(std::chrono::milliseconds(100)); // Simulate a 100ms frame time
    }
}

int main() {
    std::vector gameObjects;
    Player player;
    gameObjects.push_back(&player);

    gameLoop(gameObjects);

    return 0;
}

#include <iostream>
#include <chrono>
#include <thread>
#include <string>
#include <vector>

class GameObject {
public:
    virtual void update() = 0;
    virtual void render() = 0;
};

class Player : public GameObject {
private:
    int x, y;
public:
    Player() : x(0), y(0) {}
    void update() override {
        x++;
        y++;
    }
    void render() override {
        std::cout << "Player rendered at (" << x << ", " << y << ")" << std::endl;
    }
};

class Enemy : public GameObject {
private:
    int x, y;
    bool movingRight = true;
public:
    Enemy() : x(10), y(10) {}
    void update() override {
        if (movingRight) {
            x++;
            if (x > 15) movingRight = false;
        } else {
            x--;
            if (x < 5) movingRight = true;
        }
    }
    void render() override {
        std::cout << "Enemy rendered at (" << x << ", " << y << ")" << std::endl;
    }
};

void gameLoop(std::vector& objects) {
    // ... same as above
    auto lastFrameTime = std::chrono::high_resolution_clock::now();
    for(int i = 0; i < 5; ++i) {
        auto currentFrameTime = std::chrono::high_resolution_clock::now();
        std::chrono::duration deltaTime = currentFrameTime - lastFrameTime;
        lastFrameTime = currentFrameTime;

        std::cout << "--- Frame " << i+1 << " ---" << std::endl;

        for (auto obj : objects) {
            obj->update();
        }

        for (auto obj : objects) {
            obj->render();
        }
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}

int main() {
    std::vector gameObjects;
    Player player;
    Enemy enemy;
    gameObjects.push_back(&player);
    gameObjects.push_back(&enemy); // Add the new enemy

    gameLoop(gameObjects);

    return 0;
}

Lesson 4: System Programming

Beyond applications, C++ is a powerful language for **system programming**, which involves building software that interacts directly with the operating system and hardware. This includes writing device drivers, operating system kernels, embedded systems, and high-performance computing applications. C++'s low-level access to memory, direct control over resources, and performance-oriented nature make it uniquely suited for these tasks. While other languages might offer a higher level of abstraction, C++ gives the programmer the tools to optimize code to the bare metal, which is a non-negotiable requirement for systems where every microsecond and every byte of memory counts. Understanding system programming with C++ provides a deeper understanding of how computers work and is a crucial skill for anyone interested in fields like cybersecurity, high-frequency trading, and robotics.

Key concepts in C++ system programming include:

• Interfacing with the Operating System: This involves using system calls to interact with the OS for tasks such as file management, process creation, and network communication. While C++'s standard library provides high-level abstractions for many of these tasks (e.g., `` for files), system programmers often need to work with the native C APIs exposed by the operating system for maximum control and performance. For example, on a Linux system, this might involve using functions like `open()`, `read()`, and `write()` instead of the standard library's `iostream` classes. This direct interaction allows for more fine-grained control and is often necessary for writing kernel modules or device drivers.
• Memory Mapping: This is a technique for mapping a file or a device to a region of a program's virtual memory. Once mapped, the program can access the file's contents as if they were in memory, which can be much faster than traditional file I/O operations. This is a common technique in high-performance computing and for writing low-latency systems.
• Embedded Systems: C++ is a popular choice for programming embedded systems, which are small, specialized computer systems designed for a specific purpose (e.g., in a car, a smart appliance, or a medical device). The language's efficiency and ability to run with minimal overhead are crucial in these resource-constrained environments. System programmers working on embedded systems often need to write code that directly manipulates hardware registers, which requires a deep understanding of memory addresses and bitwise operations.
• Performance-Critical Code: In system programming, performance is paramount. C++ allows for a zero-cost abstraction model, which means that the abstractions you use (like classes and templates) do not introduce unnecessary performance overhead. This allows you to write high-level, readable code that compiles down to highly efficient machine code. Features like `const`, `inline`, and move semantics are all tools that help the compiler produce more optimized code.

The transition from application programming to system programming is a significant one, as it requires a much deeper understanding of the underlying hardware and operating system. However, the rewards are great. System programmers build the foundation upon which all other software is built. With C++, you have the perfect tool for the job. You can write code that is not only powerful and efficient but also portable across different systems, as long as you adhere to the standard and use portable APIs where possible. The code below provides a very simple example of interacting with the system, but in real-world scenarios, this would be much more complex and involve specific system APIs.

#include <iostream>
#include <string>
#include  // For C-style I/O
#include  // For system() call

int main() {
    std::cout << "Running a system command..." << std::endl;
    // Execute a command-line command using the C standard library function
    // This is a simple way to interact with the system
    #ifdef _WIN32
        system("dir"); // For Windows
    #else
        system("ls -l"); // For Linux/macOS
    #endif

    std::cout << "\nCreating a file using C++ streams..." << std::endl;
    // We already learned about this, but it's a good example of system interaction
    FILE* file = fopen("testfile.txt", "w");
    if (file) {
        fprintf(file, "This file was created by a C++ program.\n");
        fclose(file);
        std::cout << "File 'testfile.txt' created successfully." << std::endl;
    } else {
        std::cerr << "Error creating file." << std::endl;
    }

    return 0;
}

#include <iostream>
#include <string>
#include <cstdlib>

int main() {
    const char* path_var = getenv("PATH");
    if (path_var) {
        std::cout << "The value of the PATH environment variable is:" << std::endl;
        std::cout << path_var << std::endl;
    } else {
        std::cerr << "The PATH environment variable could not be found." << std::endl;
    }

    return 0;
}

Lesson 5: Performance Optimization

As we've seen throughout this course, C++ is a language renowned for its performance. However, simply writing C++ code does not automatically guarantee high performance. To write truly fast code, you must be a conscious programmer, making deliberate choices that lead to optimal performance. **Performance optimization** is the process of modifying a program to make it run more efficiently, either by reducing its execution time or by minimizing its memory usage. This is a critical skill for any C++ developer, especially in fields like game development, high-frequency trading, scientific computing, and system programming, where every millisecond counts. This lesson will provide an overview of some of the key techniques and considerations for writing high-performance C++ code, drawing on many of the concepts we've already learned.

The first rule of performance optimization is: **"Don't optimize prematurely."** It is often better to write clean, readable code first and then profile it to find the bottlenecks. **Profiling** is the process of measuring the performance of a program to identify the areas that consume the most resources. Once you have identified the "hot spots" (the parts of the code that are executed most frequently), you can focus your optimization efforts there. The second rule of performance optimization is: **"Know your hardware."** A deep understanding of how modern CPUs work, including concepts like cache memory, branch prediction, and instruction pipelining, is essential for writing truly optimized code. For example, by arranging your data in a way that promotes **data locality**, you can minimize cache misses and dramatically improve performance. This often means preferring a `std::vector` over a `std::list` for certain tasks, as the contiguous memory layout of a vector is much more cache-friendly. The key is to write code that works well with the hardware, not against it.

Key Optimization Techniques

Here are some key C++-specific techniques for performance optimization:

• Algorithm and Data Structure Choice: The choice of algorithm and data structure can have the biggest impact on performance. Using a `std::map` for a million elements when you only need to store 100 is a clear performance mistake. Similarly, using a simple linear search when a binary search would be possible and faster is a poor choice. The STL provides a rich set of containers and algorithms, and knowing when to use each is crucial.
• Compiler Optimizations: The C++ compiler is a powerful tool. By using the right flags (e.g., `-O2` or `-O3` in GCC/Clang), you can tell the compiler to perform a wide range of optimizations, such as function inlining, loop unrolling, and dead code elimination. It's a good practice to always compile with a high optimization level in your release builds.
• Avoid Unnecessary Dynamic Allocation: As we learned in the memory management module, dynamic memory allocation on the heap is slower than stack allocation. You should try to minimize the number of `new` and `delete` calls in performance-critical code. This is another reason why smart pointers and the Rule of Zero are so important, as they help you manage memory without manual intervention.
• Move Semantics: This feature, introduced in C++11, is a key to high performance. By moving resources instead of copying them, you can avoid costly memory allocations and deallocations. This is especially important for classes that manage large blocks of memory, like `std::vector` and `std::string`.
• Parallelism and Concurrency: As we discussed in the last lesson, using multiple threads to perform tasks in parallel can drastically improve performance on multi-core systems. The `` and `` libraries provide a high-level, portable way to harness this power. The choice between using a single, highly optimized thread or multiple, less optimized threads is a common design trade-off that depends on the specific problem you are trying to solve.

Performance optimization is a vast and fascinating topic. It requires a blend of theoretical knowledge, practical experience, and a good understanding of your tools and hardware. By applying the principles we've discussed throughout this course, you'll be well on your way to writing C++ code that is not only correct but also blazingly fast. The code below provides a simple example of the performance difference between a contiguous and non-contiguous container.

#include <iostream>
#include <vector>
#include <list>
#include <chrono>

const int NUM_ELEMENTS = 1000000;

void benchmark_vector() {
    std::vector numbers(NUM_ELEMENTS);
    auto start = std::chrono::high_resolution_clock::now();
    
    for (int i = 0; i < NUM_ELEMENTS; ++i) {
        numbers[i] = i;
    }
    
    auto end = std::chrono::high_resolution_clock::now();
    std::chrono::duration duration = end - start;
    std::cout << "Vector fill time: " << duration.count() << " ms" << std::endl;
}

void benchmark_list() {
    std::list numbers;
    auto start = std::chrono::high_resolution_clock::now();

    for (int i = 0; i < NUM_ELEMENTS; ++i) {
        numbers.push_back(i);
    }
    
    auto end = std::chrono::high_resolution_clock::now();
    std::chrono::duration duration = end - start;
    std::cout << "List fill time:   " << duration.count() << " ms" << std::endl;
}

int main() {
    std::cout << "Benchmarking performance for different containers..." << std::endl;
    benchmark_vector();
    benchmark_list();

    return 0;
}

#include <iostream>
#include <chrono>

const long long N = 100000000;

int main() {
    long long sum_loop = 0;
    
    // Method 1: Using a standard loop
    auto start_loop = std::chrono::high_resolution_clock::now();
    for (long long i = 1; i <= N; ++i) {
        sum_loop += i;
    }
    auto end_loop = std::chrono::high_resolution_clock::now();
    std::chrono::duration duration_loop = end_loop - start_loop;
    
    std::cout << "Sum (loop): " << sum_loop << std::endl;
    std::cout << "Time taken (loop): " << duration_loop.count() << " ms" << std::endl;

    // Method 2: Using a mathematical formula
    auto start_formula = std::chrono::high_resolution_clock::now();
    long long sum_formula = (N * (N + 1)) / 2;
    auto end_formula = std::chrono::high_resolution_clock::now();
    std::chrono::duration duration_formula = end_formula - start_formula;

    std::cout << "Sum (formula): " << sum_formula << std::endl;
    std::cout << "Time taken (formula): " << duration_formula.count() << " ms" << std::endl;

    return 0;
}