Khóa học C++ từ cơ bản đến nâng cao

class TenLopDanXuat : public TenLopCoSo {
    // Các thành viên riêng của lớp dẫn xuất
};

#include <iostream>
#include <string>

// Lớp cơ sở
class Animal {
public:
    int age;

    Animal(int initialAge) : age(initialAge) { // Constructor
        cout << "Animal constructor called with age: " << age << endl;
    }

    void eat() const { // Phương thức công khai
        cout << "This animal is eating." << endl;
    }

    // Destructor (Quan sát thứ tự gọi)
    ~Animal() {
        cout << "Animal destructor called." << endl;
    }
};

// Lớp dẫn xuất kế thừa công khai từ Animal
class Dog : public Animal {
public:
    string breed;

    // Constructor của Dog, gọi constructor của Base class
    Dog(int initialAge, const string& dogBreed) : Animal(initialAge), breed(dogBreed) {
        cout << "Dog constructor called for breed: " << breed << endl;
    }

    void bark() const { // Phương thức riêng của Dog
        cout << "Woof! Woof!" << endl;
    }

    // Destructor (Quan sát thứ tự gọi)
    ~Dog() {
        cout << "Dog destructor called." << endl;
    }
};

int main() {
    // Tạo một đối tượng Dog
    Dog myDog(3, "Labrador");

    cout << "My dog is " << myDog.age << " years old and is a " << myDog.breed << "." << endl;

    // Gọi phương thức kế thừa từ Animal
    myDog.eat();

    // Gọi phương thức riêng của Dog
    myDog.bark();

    // Khi myDog ra khỏi phạm vi, destructor sẽ được gọi theo thứ tự ngược lại
    return 0;
}

#include <iostream>
#include <string>

// Lớp cơ sở với thành viên protected
class Animal {
protected: // Thay đổi từ public sang protected
    int age;

public:
    Animal(int initialAge) : age(initialAge) {
        cout << "Animal constructor called with age: " << age << endl;
    }

    void eat() const {
        cout << "This animal is eating." << endl;
    }

    // Destructor
    ~Animal() {
        cout << "Animal destructor called." << endl;
    }
};

// Lớp dẫn xuất kế thừa công khai
class Dog : public Animal {
public:
    string breed;

    Dog(int initialAge, const string& dogBreed) : Animal(initialAge), breed(dogBreed) {
        cout << "Dog constructor called for breed: " << breed << endl;
    }

    void bark() const {
        cout << "Woof! Woof!" << endl;
    }

    // Phương thức riêng của Dog có thể truy cập age (protected)
    void displayAge() const {
        cout << "Dog's age (accessed from Dog class): " << age << endl;
    }

    // Destructor
    ~Dog() {
        cout << "Dog destructor called." << endl;
    }
};

int main() {
    Dog myDog(4, "Poodle");

    myDog.displayAge(); // Hợp lệ: Truy cập 'age' từ bên trong lớp Dog

    // myDog.age = 5; // LỖI: Không thể truy cập thành viên protected từ bên ngoài lớp

    myDog.eat();
    myDog.bark();

    return 0;
}

#include <iostream>

// Lớp cơ sở
class Animal {
public:
    Animal() {
        cout << "Animal created." << endl;
    }

    // Phương thức chung (có thể ghi đè)
    void speak() const {
        cout << "Animal makes a sound." << endl;
    }

    virtual ~Animal() { // Destructor ảo để đảm bảo hủy đúng thứ tự với polymorphic
        cout << "Animal destroyed." << endl;
    }
};

// Lớp dẫn xuất 1
class Dog : public Animal {
public:
    Dog() {
        cout << "Dog created." << endl;
    }

    // Ghi đè phương thức speak()
    void speak() const {
        cout << "Woof!" << endl;
    }

    ~Dog() override { // Có thể dùng override để kiểm tra xem có thật sự ghi đè không
        cout << "Dog destroyed." << endl;
    }
};

// Lớp dẫn xuất 2
class Cat : public Animal {
public:
    Cat() {
        cout << "Cat created." << endl;
    }

    // Ghi đè phương thức speak()
    void speak() const {
        cout << "Meow!" << endl;
    }

     ~Cat() override {
        cout << "Cat destroyed." << endl;
    }
};

int main() {
    Animal genericAnimal;
    Dog myDog;
    Cat myCat;

    cout << "--- Calling speak() ---" << endl;

    genericAnimal.speak(); // Gọi phương thức của Animal
    myDog.speak();         // Gọi phương thức đã ghi đè của Dog
    myCat.speak();         // Gọi phương thức đã ghi đè của Cat

    cout << "--- End of program ---" << endl; // Destructor sẽ được gọi sau

    return 0;
}

#include <iostream>
#include <string>

// Lớp cơ sở cấp 1
class Vehicle {
public:
    int maxSpeed;

    Vehicle(int speed) : maxSpeed(speed) {
        cout << "Vehicle constructor called with speed: " << maxSpeed << endl;
    }

    void displaySpeed() const {
        cout << "Max speed: " << maxSpeed << " km/h" << endl;
    }

    ~Vehicle() { cout << "Vehicle destroyed." << endl; }
};

// Lớp dẫn xuất cấp 2, kế thừa từ Vehicle
class Car : public Vehicle {
public:
    string make;
    string model;

    Car(int speed, const string& carMake, const string& carModel)
        : Vehicle(speed), make(carMake), model(carModel) { // Gọi constructor lớp cơ sở cấp 1
        cout << "Car constructor called for " << make << " " << model << endl;
    }

    void displayInfo() const {
        cout << "Car: " << make << " " << model << endl;
        displaySpeed(); // Có thể gọi phương thức của lớp cơ sở cấp 1
    }

    ~Car() override { cout << "Car destroyed." << endl; }
};

// Lớp dẫn xuất cấp 3, kế thừa từ Car
class SportsCar : public Car {
public:
    bool hasTurbo;

    SportsCar(int speed, const string& carMake, const string& carModel, bool turbo)
        : Car(speed, carMake, carModel), hasTurbo(turbo) { // Gọi constructor lớp cơ sở cấp 2
        cout << "SportsCar constructor called. Turbo: " << (hasTurbo ? "Yes" : "No") << endl;
    }

    void displaySportsInfo() const {
        displayInfo(); // Có thể gọi phương thức của lớp cơ sở cấp 2 (mà lớp cơ sở cấp 2 gọi lớp cơ sở cấp 1)
        cout << "Has Turbo: " << (hasTurbo ? "Yes" : "No") << endl;
    }

    ~SportsCar() override { cout << "SportsCar destroyed." << endl; }
};

int main() {
    SportsCar mySportsCar(300, "Ferrari", "458", true);

    cout << "--- Displaying info ---" << endl;
    mySportsCar.displaySportsInfo(); // Gọi phương thức lớp dẫn xuất cấp 3
    // mySportsCar.displayInfo(); // Có thể gọi trực tiếp phương thức lớp dẫn xuất cấp 2
    // mySportsCar.displaySpeed(); // Có thể gọi trực tiếp phương thức lớp cơ sở cấp 1

    cout << "--- Accessing members ---" << endl;
    cout << "Make: " << mySportsCar.make << endl; // Truy cập thành viên lớp cơ sở cấp 2
    cout << "Max Speed: " << mySportsCar.maxSpeed << endl; // Truy cập thành viên lớp cơ sở cấp 1

    cout << "--- End of program ---" << endl;

    return 0;
}

#include <iostream>
#include <string>

class BaseUtility {
public:
    void logMessage(const string& msg) const {
        cout << "[LOG] " << msg << endl;
    }

protected:
    int internalCounter = 0;
    void incrementCounter() {
        internalCounter++;
    }

private:
    int secretValue = 100;
};

// Lớp dẫn xuất sử dụng private inheritance
class Processor : private BaseUtility {
public:
    void processData(const string& data) {
        // Có thể truy cập thành viên public và protected của BaseUtility
        logMessage("Processing data: " + data);
        incrementCounter();
        // secretValue = 200; // LỖI: Không thể truy cập thành viên private của BaseUtility
    }

    void displayStatus() const {
        // logMessage("Current count: " + to_string(internalCounter)); // LỖI: Cannot access logMessage here!
        // Vì BaseUtility::logMessage trở thành private trong Processor
        // internalCounter; // LỖI: Cannot access internalCounter here!
        // Vì BaseUtility::internalCounter trở thành private trong Processor

        // Cần tạo một phương thức riêng trong Processor để truy cập
        cout << "[STATUS] Processing complete. Internal count: " << internalCounter << endl; // VẪN LỖI!
        // Okay, let's fix this. In private inheritance, public/protected members of Base
        // become private in Derived. This means they *can* be accessed *inside* Derived,
        // but NOT by objects *of* Derived *from outside*.

        // Correct access:
        // Các thành viên public/protected của BaseUtility đã trở thành private trong Processor.
        // Chúng CHỈ CÓ THỂ được truy cập BÊN TRONG các phương thức của lớp Processor.
        // Chúng KHÔNG THỂ được truy cập BỞI đối tượng Processor từ bên ngoài main().
        // Đoạn code dưới đây đúng ra phải nằm trong một method khác của Processor.
        // Để demo access *within* Processor:
        cout << "[STATUS] Processing complete. Internal count: " << internalCounter << endl; // OK (đang ở trong method của Processor)
        // logMessage("Another status message."); // OK (đang ở trong method của Processor)

    }
     // Helper method inside Processor to demonstrate accessing private-inherited members
    void showInternalDetails() {
        logMessage("Showing internal details (accessed within Processor method)."); // OK
        cout << "Internal counter is: " << internalCounter << endl; // OK
    }
};

int main() {
    Processor myProcessor;

    myProcessor.processData("Initial data");
    myProcessor.processData("More data");

    // myProcessor.logMessage("This message?"); // LỖI: logMessage là private trong Processor
    // myProcessor.incrementCounter(); // LỖI: incrementCounter là private trong Processor
    // myProcessor.internalCounter; // LỖI: internalCounter là private trong Processor

    myProcessor.showInternalDetails(); // Gọi phương thức riêng của Processor để truy cập thành viên kế thừa (giờ là private)

    return 0;
}