C++ for C Developers | Lesson 8: Inheritance: Building on What You Have (Code Reuse)

class Base {
    // ... base class members ...
};

class Derived : public Base { // Derived inherits publicly from Base
    // ... members specific to Derived ...
};

#include <iostream>
#include <string>

// --- Base Class ---
class Animal {
private: // Private to Animal
    std::string m_internal_id; // Only accessible via Animal's methods

protected: // Accessible by Animal and derived classes (like Dog)
    std::string m_species;
    int m_age;

public: // Accessible by anyone
    // Constructor for Animal
    Animal(const std::string& species, int age)
        : m_species(species), m_age(age)
    {
        // Generate some internal ID (example)
        m_internal_id = species + std::to_string(age); // std::to_string needs <string>
        std::cout << "Animal Constructor for " << m_species << std::endl;
    }

    // Destructor for Animal
    ~Animal() {
         std::cout << "Animal Destructor for " << m_species << std::endl;
    }

    // Public methods
    void eat() const {
        std::cout << "The " << m_species << " is eating." << std::endl;
    }

    void sleep() const {
        std::cout << "The " << m_species << " is sleeping." << std::endl;
    }

    int getAge() const {
        return m_age; // Provide public access to protected data if needed
    }

    std::string getSpecies() const {
        return m_species;
    }

    std::string getInternalIdInfo() const {
        // Derived classes cannot access m_internal_id directly,
        // but they can call this public method.
        return "Internal ID starts with: " + m_internal_id.substr(0, 4) + "...";
    }
};

// --- Derived Class ---
class Dog : public Animal { // Dog "is-a" Animal (publicly inherits)
private: // Specific to Dog
    std::string m_breed;
    std::string m_owner_name;

public:
    // Dog's Constructor - MUST call the Base class (Animal) constructor
    Dog(const std::string& breed, int age, const std::string& owner)
        : Animal("Dog", age), // *** Call Animal constructor via initialization list ***
          m_breed(breed),
          m_owner_name(owner)
    {
        std::cout << "Dog Constructor for breed " << m_breed << std::endl;
    }

    ~Dog() {
         std::cout << "Dog Destructor for breed " << m_breed << std::endl;
    }

    // Dog-specific method
    void bark() const {
        // Can access protected members from Animal directly
        std::cout << "The " << m_age << "-year-old " << m_species << " (breed: " << m_breed << ") says: Woof! Woof!" << std::endl;
        // std::cout << m_internal_id; // ERROR! Cannot access private base member
    }

    // Can call public methods inherited from Animal
    void fetch() const {
        std::cout << m_owner_name << "'s dog (" << m_species << ") is fetching." << std::endl;
        eat(); // Call inherited public method
    }

    // We can provide a Dog-specific version of an Animal method (Overriding preview)
    void sleep() const {
        std::cout << "The dog (" << m_breed << ") curls up to sleep." << std::endl;
        // Can still call the base version if needed:
        // Animal::sleep();
    }

     void showInternalIdHint() const {
        // Can access Base's private data *indirectly* via Base's public method
        std::cout << getInternalIdInfo() << std::endl;
     }
};


int main() {
    std::cout << "--- Creating Dog object ---" << std::endl;
    Dog myDog("Golden Retriever", 5, "Alice");
    std::cout << "-------------------------\n" << std::endl;

    // Call methods:
    myDog.eat();          // Inherited from Animal
    myDog.bark();         // Defined in Dog
    myDog.fetch();        // Defined in Dog (calls inherited eat())
    myDog.sleep();        // Uses the Dog version (overrides Animal's)
    myDog.showInternalIdHint(); // Calls inherited method to access private base data hint

    std::cout << "\nMy dog's species: " << myDog.getSpecies() << std::endl; // Inherited public method
    std::cout << "My dog's age: " << myDog.getAge() << std::endl;      // Inherited public method

    // Cannot access protected members from outside:
    // std::cout << myDog.m_species; // ERROR! m_species is protected

    // Cannot access private members from outside:
    // std::cout << myDog.m_breed; // ERROR! m_breed is private to Dog
    // std::cout << myDog.m_internal_id; // ERROR! m_internal_id is private to Animal


    std::cout << "\n--- Dog object going out of scope ---" << std::endl;
    // Destructors called in reverse order of construction:
    // 1. Dog destructor
    // 2. Animal destructor
    return 0;
}