C++ Inheritance — Missing Virtual Destructor Leak

#include <iostream>
#include <string>

// Base class — contains everything common to ALL vehicles
class Vehicle {
public:
    std::string make;
    std::string model;
    int year;

    // Constructor: initialises the core vehicle data
    Vehicle(const std::string& make, const std::string& model, int year)
        : make(make), model(model), year(year) {}

    // Any vehicle can display its basic identity
    void displayInfo() const {
        std::cout << year << " " << make << " " << model;
    }
};

// Derived class — inherits Vehicle publicly, then extends it
class Car : public Vehicle {
public:
    int numberOfDoors;

    // We call Vehicle's constructor via the initialiser list
    // — the base part is constructed FIRST, always
    Car(const std::string& make, const std::string& model,
        int year, int doors)
        : Vehicle(make, model, year), numberOfDoors(doors) {}

    // Car-specific display — reuses the base method then adds its own info
    void displayCarInfo() const {
        displayInfo();  // inherited from Vehicle — no duplication needed
        std::cout << " | Doors: " << numberOfDoors << "\n";
    }
};

int main() {
    Vehicle genericVehicle("Generic", "Transport", 2020);
    genericVehicle.displayInfo();
    std::cout << "\n";

    Car familyCar("Toyota", "Camry", 2023, 4);
    familyCar.displayCarInfo();

    // Car inherits make/model/year directly — no extra code needed
    std::cout << "Make accessed directly: " << familyCar.make << "\n";

    return 0;
}

#include <iostream>
#include <string>

class Engine {
public:
    void start() { std::cout << "Engine started\n"; }
    void stop()  { std::cout << "Engine stopped\n"; }
protected:
    int horsepower = 150;
private:
    std::string serialNumber = "ENG-XZ99"; // nobody outside Engine touches this
};

// PUBLIC inheritance — Car IS-A Engine (conceptually makes sense to expose API)
class PublicCar : public Engine {
public:
    void drive() {
        start();             // OK — public inherited, stays public
        std::cout << "Driving with " << horsepower << " HP\n"; // OK — protected
        // serialNumber;     // COMPILE ERROR — private is always off-limits
    }
};

// PRIVATE inheritance — ElectricBooster uses Engine internally
// The world outside ElectricBooster cannot call start() or stop()
class ElectricBooster : private Engine {
public:
    void activate() {
        start();  // OK inside the class — but outsiders can't call booster.start()
        std::cout << "Booster running at " << horsepower << " HP\n";
    }
};

int main() {
    PublicCar sportsCar;
    sportsCar.start();   // Fine — public inheritance keeps it public
    sportsCar.drive();
    sportsCar.stop();

    std::cout << "---\n";

    ElectricBooster booster;
    booster.activate();  // Fine — activate() is public
    // booster.start();  // COMPILE ERROR — start() is now private via private inheritance

    return 0;
}

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

// Abstract base class — cannot be instantiated directly
// Any class that forgets to implement fuelCost() won't compile
class Vehicle {
public:
    std::string make;
    int milesDriven;

    Vehicle(const std::string& make, int miles)
        : make(make), milesDriven(miles) {}

    // Pure virtual — every vehicle MUST define how fuel cost is calculated
    virtual double fuelCost() const = 0;

    // Virtual with a default — derived classes CAN override but don't have to
    virtual std::string fuelType() const {
        return "Unknown";
    }

    // Non-virtual: this behaviour should NEVER change per subtype
    void printSummary() const {
        std::cout << make
                  << " | Fuel: " << fuelType()
                  << " | Cost for " << milesDriven
                  << " miles: $" << fuelCost() << "\n";
    }

    // ALWAYS declare the destructor virtual in a polymorphic base class
    // (see Gotchas section — this one bites hard)
    virtual ~Vehicle() = default;
};

class PetrolCar : public Vehicle {
    double milesPerGallon;
    double pricePerGallon;
public:
    PetrolCar(const std::string& make, int miles,
              double mpg, double pricePerGallon)
        : Vehicle(make, miles),
          milesPerGallon(mpg),
          pricePerGallon(pricePerGallon) {}

    // override keyword tells the compiler: "check that I'm actually overriding"
    double fuelCost() const override {
        return (milesDriven / milesPerGallon) * pricePerGallon;
    }

    std::string fuelType() const override { return "Petrol"; }
};

class ElectricCar : public Vehicle {
    double milesPerKWh;
    double pricePerKWh;
public:
    ElectricCar(const std::string& make, int miles,
                double milesPerKWh, double pricePerKWh)
        : Vehicle(make, miles),
          milesPerKWh(milesPerKWh),
          pricePerKWh(pricePerKWh) {}

    double fuelCost() const override {
        return (milesDriven / milesPerKWh) * pricePerKWh;
    }

    std::string fuelType() const override { return "Electric"; }
};

int main() {
    // Store different vehicle types through a common base pointer
    // This is the power: the vector doesn't care which subtype it holds
    std::vector<std::unique_ptr<Vehicle>> fleet;

    fleet.push_back(std::make_unique<PetrolCar>("Ford F-150", 300, 20.0, 3.50));
    fleet.push_back(std::make_unique<ElectricCar>("Tesla Model 3", 300, 4.0, 0.13));
    fleet.push_back(std::make_unique<PetrolCar>("Honda Civic", 300, 35.0, 3.50));

    std::cout << "=== Fleet Cost Report ===\n";
    for (const auto& vehicle : fleet) {
        vehicle->printSummary(); // correct fuelCost() called automatically
    }

    return 0;
}

#include <iostream>
#include <string>

// Grandparent — the single shared root
class Device {
public:
    std::string deviceId;
    Device(const std::string& id) : deviceId(id) {
        std::cout << "Device constructed: " << id << "\n";
    }
    virtual ~Device() = default;
};

// virtual inheritance ensures only ONE Device sub-object exists
class NetworkDevice : virtual public Device {
public:
    NetworkDevice(const std::string& id) : Device(id) {}
    void sendPacket() { std::cout << deviceId << " sending packet\n"; }
};

class StorageDevice : virtual public Device {
public:
    StorageDevice(const std::string& id) : Device(id) {}
    void writeData() { std::cout << deviceId << " writing data\n"; }
};

// SmartRouter inherits from BOTH — classic diamond shape
// Because both parents used virtual inheritance, Device is constructed ONCE
// The most-derived class (SmartRouter) MUST call Device's constructor directly
class SmartRouter : public NetworkDevice, public StorageDevice {
public:
    SmartRouter(const std::string& id)
        : Device(id),            // required: most-derived calls virtual base
          NetworkDevice(id),
          StorageDevice(id) {}

    void status() {
        // No ambiguity — there's only one deviceId
        std::cout << "Router " << deviceId << " is operational\n";
    }
};

int main() {
    std::cout << "--- Without virtual inheritance, Device would construct TWICE ---\n";
    std::cout << "--- With virtual inheritance, it constructs exactly once:      ---\n\n";

    SmartRouter router("RTR-001");
    router.sendPacket();
    router.writeData();
    router.status();

    return 0;
}

#include <iostream>
#include <memory>
#include <string>

// ---- Inheritance approach ----
class Logger {
public:
    virtual void log(const std::string& msg) const {
        std::cout << "[Inheritance] " << msg << "\n";
    }
    virtual ~Logger() = default;
};

class ServiceWithInheritance : public Logger {
public:
    void doWork() {
        // 'log' is inherited, but the relationship is now IS-A Logger
        log("Working...");
    }
};

// ---- Composition approach ----
class ServiceWithComposition {
    std::shared_ptr<Logger> logger_; // can be any Logger implementation
public:
    explicit ServiceWithComposition(std::shared_ptr<Logger> logger)
        : logger_(std::move(logger)) {}
    void doWork() {
        // delegation: uses logger, not inherits
        logger_->log("Working...");
    }
};

class FileLogger : public Logger {
public:
    void log(const std::string& msg) const override {
        std::cout << "[File] " << msg << "\n";  // pretend file I/O
    }
};

int main() {
    // Inheritance: fixes the Logger type at compile time
    ServiceWithInheritance svc_inherit;
    svc_inherit.doWork();

    // Composition: can swap logger at runtime
    auto fileLogger = std::make_shared<FileLogger>();
    ServiceWithComposition svc_compose(fileLogger);
    svc_compose.doWork();

    // Composition also works with the default Logger
    auto defaultLogger = std::make_shared<Logger>();
    ServiceWithComposition svc_compose2(defaultLogger);
    svc_compose2.doWork();

    return 0;
}