Understanding Inheritance in C++

#include <iostream>
#include <string>

// Base class representing a generic animal
class Animal {
protected:
    std::string name; // Name of the animal
    int age;          // Age of the animal

public:
    // Constructor to initialize the name and age
    Animal(const std::string& name, int age)
        : name(name), age(age) {}

    // Virtual function to make a sound
    // Can be overridden by derived classes
    virtual void makeSound() const {
        std::cout << "Some generic animal sound" << std::endl;
    }

    // Function to display the animal's information
    void displayInfo() const {
        std::cout << "Name: " << name << ", Age: " << age << std::endl;
    }
};

// Derived class representing a Dog, inheriting from Animal
class Dog : public Animal {
public:
    // Constructor to initialize the Dog using the Animal constructor
    Dog(const std::string& name, int age)
        : Animal(name, age) {}

    // Override the makeSound function to provide a specific behaviour for dogs
    void makeSound() const override {
        std::cout << "Woof! Woof!" << std::endl;
    }
};

int main() {
    // Create an instance of Animal
    Animal genericAnimal("Generic", 5);

    // Create an instance of Dog
    Dog rover("Rover", 3);

    // Display information and sound for the generic animal
    std::cout << "Generic Animal:" << std::endl;
    genericAnimal.displayInfo();
    genericAnimal.makeSound();

    // Display information and sound for the dog
    std::cout << "\nDog:" << std::endl;
    rover.displayInfo();
    rover.makeSound();

    return 0;
}

#include <iostream>

// Base class providing a basic value and functionality
class Base {
protected:
    int value; // A protected integer that derived classes can access
public:
    // Constructor to initialize the value
    Base(int v) : value(v) {}

    // Method to display the current value
    void display() const {
        std::cout << "Value: " << value << std::endl;
    }
};

// Single Inheritance: Derived inherits from Base
class Derived : public Base {
public:
    // Constructor to initialize the base class
    Derived(int v) : Base(v) {}

    // Method to multiply the value by a given factor
    void multiply(int factor) {
        value *= factor;
    }
};

// Multiple Inheritance example

// Engine class represents a car's engine type
class Engine {
protected:
    std::string type; // Type of the engine (e.g., V8, Electric)
public:
    // Constructor to initialize the engine type
    Engine(const std::string& t) : type(t) {}

    // Method to simulate starting the engine
    void start() {
        std::cout << type << " engine starting..." << std::endl;
    }
};

// Vehicle class represents a general vehicle
class Vehicle {
protected:
    std::string brand; // Brand of the vehicle (e.g., Toyota)
public:
    // Constructor to initialize the vehicle's brand
    Vehicle(const std::string& b) : brand(b) {}

    // Method to display the vehicle's brand
    void displayBrand() {
        std::cout << "Brand: " << brand << std::endl;
    }
};

// Car class inherits from both Engine and Vehicle
class Car : public Engine, public Vehicle {
public:
    // Constructor to initialize both the engine and vehicle attributes
    Car(const std::string& type, const std::string& brand)
        : Engine(type), Vehicle(brand) {}

    // Method to display car info by combining Engine and Vehicle behaviour
    void info() {
        displayBrand();
        start();
    }
};

int main() {
    // Single inheritance example
    Derived d(5);      // Create an object of Derived with value 5
    d.display();       // Output the initial value
    d.multiply(3);     // Multiply value by 3
    d.display();       // Output the updated value

    std::cout << "\n";

    // Multiple inheritance example
    Car car("V8", "Toyota"); // Create a Car object with a V8 engine and Toyota brand
    car.info();              // Display car information (brand and engine type)

    return 0;
}

#include <iostream>
#include <vector>
#include <memory>

// Abstract base class representing a general shape
class Shape {
public:
    virtual ~Shape() = default; // Virtual destructor for proper cleanup
    virtual double area() const = 0;  // Pure virtual function to compute area
    virtual void draw() const = 0;   // Pure virtual function to draw the shape
};

// Derived class representing a Circle
class Circle : public Shape {
private:
    double radius; // Radius of the circle

public:
    // Constructor to initialize the radius
    Circle(double r) : radius(r) {}

    // Override the area function to compute the circle's area
    double area() const override {
        return 3.14159 * radius * radius;
    }

    // Override the draw function to display a circle-specific message
    void draw() const override {
        std::cout << "Drawing a circle" << std::endl;
    }
};

// Derived class representing a Rectangle
class Rectangle : public Shape {
private:
    double width;  // Width of the rectangle
    double height; // Height of the rectangle

public:
    // Constructor to initialize width and height
    Rectangle(double w, double h) : width(w), height(h) {}

    // Override the area function to compute the rectangle's area
    double area() const override {
        return width * height;
    }

    // Override the draw function to display a rectangle-specific message
    void draw() const override {
        std::cout << "Drawing a rectangle" << std::endl;
    }
};

int main() {
    // Vector to store unique pointers to Shape objects
    std::vector<std::unique_ptr<Shape>> shapes;

    // Add a Circle object to the vector
    shapes.push_back(std::make_unique<Circle>(5));

    // Add a Rectangle object to the vector
    shapes.push_back(std::make_unique<Rectangle>(4, 6));

    // Iterate through each shape in the vector
    for (const auto& shape : shapes) {
        shape->draw();  // Calls the appropriate draw() method based on the object type
        std::cout << "Area: " << shape->area() << std::endl; // Outputs the area
    }

    return 0;
}

#include <iostream>

// Pitfall 1: Missing virtual destructor
class Base {
public:
    Base() { std::cout << "Base constructor\n"; }
    ~Base() { std::cout << "Base destructor\n"; }  // Should be virtual!
};

class Derived : public Base {
private:
    int* data;
public:
    Derived() : data(new int[100]) {
        std::cout << "Derived constructor\n";
    }
    ~Derived() {
        delete[] data;  // Proper cleanup of allocated memory
        std::cout << "Derived destructor\n";
    }
};

// Pitfall 2: Hiding base class methods
class Parent {
public:
    // A method that takes one argument
    void display(int x) {
        std::cout << "Parent: " << x << std::endl;
    }
};

class Child : public Parent {
public:
    // A method with the same name but different arguments
    // This hides the Parent::display(int) method
    void display(int x, int y) {
        std::cout << "Child: " << x << ", " << y << std::endl;
    }
};

int main() {
    // Pitfall 1: Memory leak due to missing virtual destructor
    Base* ptr = new Derived();  // Polymorphic behaviour
    delete ptr;  // Only calls the Base destructor, causing a memory leak

    std::cout << "\n";

    // Pitfall 2: Method hiding
    Child child;
    child.display(5, 10);  // Calls Child::display(int, int)
    // child.display(5);   // Error: Parent::display(int) is hidden

    return 0;
}

#include <iostream>


// Fixing Pitfall 2: Using `using` to avoid method hiding
class Parent {
public:
    void display(int x) {
        std::cout << "Parent: " << x << std::endl;
    }
};

class Child : public Parent {
public:
    using Parent::display;  // Bring Parent::display(int) into Child's scope

    void display(int x, int y) {
        std::cout << "Child: " << x << ", " << y << std::endl;
    }
};

int main() {
    // Fix for Pitfall 2: Access both methods in Child
    Child child;
    child.display(5, 10);  // Calls Child::display(int, int)
    child.display(5);      // Now correctly calls Parent::display(int)

    return 0;
}

#include <iostream>
#include <fstream>
#include <string>
#include <memory>
#include <vector>

// Base Logger class
// Provides a common interface for different types of loggers
class Logger {
public:
    virtual ~Logger() = default; // Virtual destructor for proper cleanup
    virtual void log(const std::string& message) = 0; // Pure virtual function for logging
};

// Console Logger: Logs messages to the console
class ConsoleLogger : public Logger {
public:
    // Overrides the log method to print messages to the console
    void log(const std::string& message) override {
        std::cout << "[Console] " << message << std::endl;
    }
};

// File Logger: Logs messages to a file
class FileLogger : public Logger {
private:
    std::ofstream outFile; // File stream for writing logs

public:
    // Constructor to initialize and open the log file
    FileLogger(const std::string& fileName) {
        outFile.open(fileName, std::ios::app);
        if (!outFile.is_open()) {
            throw std::ios_base::failure("Failed to open log file");
        }
    }

    // Destructor ensures the file stream is properly closed
    ~FileLogger() {
        if (outFile.is_open()) {
            outFile.close();
        }
    }

    // Overrides the log method to write messages to the file
    void log(const std::string& message) override {
        outFile << "[File] " << message << std::endl;
    }
};

// Aggregated Logger: Combines multiple loggers
// Allows logging messages to multiple destinations simultaneously
class AggregatedLogger : public Logger {
private:
    std::vector<std::unique_ptr<Logger>> loggers; // Collection of loggers

public:
    // Adds a new logger to the collection
    void addLogger(std::unique_ptr<Logger> logger) {
        loggers.push_back(std::move(logger));
    }

    // Overrides the log method to forward messages to all loggers
    void log(const std::string& message) override {
        for (const auto& logger : loggers) {
            logger->log(message);
        }
    }
};

int main() {
    try {
        // Create a console logger
        auto consoleLogger = std::make_unique<ConsoleLogger>();

        // Create a file logger with "log.txt" as the log file
        auto fileLogger = std::make_unique<FileLogger>("log.txt");

        // Create an aggregated logger to combine console and file logging
        AggregatedLogger aggregatedLogger;

        // Add the console and file loggers to the aggregated logger
        aggregatedLogger.addLogger(std::move(consoleLogger));
        aggregatedLogger.addLogger(std::move(fileLogger));

        // Log messages using the aggregated logger
        aggregatedLogger.log("Application started");
        aggregatedLogger.log("Performing some tasks...");
        aggregatedLogger.log("Application ended");

        std::cout << "Logs written to console and file." << std::endl;
    } catch (const std::exception& e) {
        // Handle any exceptions during logging
        std::cerr << "Error: " << e.what() << std::endl;
    }

    return 0;
}