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

#include <iostream>
#include <string>
#include <vector> // Sẽ dùng sau cho Đa hình

// Sử dụng namespace std để code ngắn gọn hơn
using namespace std;

// Lớp cơ sở (Base class) - Animal
class Animal {
public:
    string name; // Thuộc tính chung

    // Hàm khởi tạo của lớp cha
    Animal(const string& n) : name(n) {
        cout << "Animal '" << name << "' created." << endl;
    }

    // Phương thức chung
    void eat() const {
        cout << name << " is eating." << endl;
    }

    // Phương thức ảo (virtual) - Quan trọng cho Đa hình
    // Mặc định mỗi loài kêu khác nhau
    virtual void speak() const {
        cout << name << " makes a generic sound." << endl;
    }

    // Hàm hủy ảo (virtual destructor) - RẤT QUAN TRỌNG khi làm việc với đa hình
    virtual ~Animal() {
        cout << "Animal '" << name << "' destroyed." << endl;
    }
};

// Lớp kế thừa (Derived class) - Dog
// Cú pháp kế thừa: class DerivedClass : access_specifier BaseClass
class Dog : public Animal {
public:
    // Hàm khởi tạo của lớp con, gọi hàm khởi tạo của lớp cha
    Dog(const string& n) : Animal(n) {
        cout << "Dog '" << name << "' created." << endl;
    }

    // Ghi đè (override) phương thức speak của lớp cha
    // 'override' là từ khóa tùy chọn nhưng nên dùng để kiểm tra lỗi
    void speak() const override {
        cout << name << " barks loudly: Woof! Woof!" << endl;
    }

    // Phương thức riêng của lớp Dog
    void fetch() const {
        cout << name << " fetches the ball." << endl;
    }

    // Ghi đè hàm hủy của lớp cha (tùy chọn nhưng tốt)
    ~Dog() override {
        cout << "Dog '" << name << "' destroyed." << endl;
    }
};

// int main() { // Tạm thời comment main để tránh xung đột khi gộp code

//     cout << "*** Minh họa Kế thừa ***" << endl;

//     // Tạo một đối tượng Dog
//     Dog myDog("Buddy");

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

//     // Gọi phương thức đã được ghi đè trong lớp Dog
//     myDog.speak();

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

//     cout << "*** Kết thúc Minh họa Kế thừa ***" << endl;

//     return 0;
// }

// Tiếp tục sử dụng các lớp đã khai báo ở trên (Animal, Dog)
// Bổ sung thêm các lớp Shape, Circle, Square

#include <iostream>
#include <vector>
#include <cmath> // Dùng M_PI cho hình tròn

using namespace std;

// Lớp cơ sở (Base class) - Shape
// Chúng ta có thể không muốn tạo đối tượng Shape thuần túy, chỉ muốn nó làm giao diện
// -> Sử dụng Pure virtual function (hàm ảo thuần túy) và biến Shape thành Abstract class
class Shape {
public:
    // Phương thức ảo thuần túy (Pure virtual function)
    // Bắt buộc các lớp con phải triển khai (implement) phương thức này
    virtual double calculateArea() const = 0;

    // Hàm hủy ảo - LUÔN LUÔN cần thiết khi lớp có phương thức ảo
    virtual ~Shape() {
        cout << "Shape destructor called." << endl;
    }
};

// Lớp kế thừa (Derived class) - Circle
class Circle : public Shape {
private:
    double radius;
public:
    Circle(double r) : radius(r) {}

    // Ghi đè phương thức ảo thuần túy
    double calculateArea() const override {
        return M_PI * radius * radius;
    }

    ~Circle() override {
        cout << "Circle destructor called." << endl;
    }
};

// Lớp kế thừa (Derived class) - Square
class Square : public Shape {
private:
    double side;
public:
    Square(double s) : side(s) {}

    // Ghi đè phương thức ảo thuần túy
    double calculateArea() const override {
        return side * side;
    }

    ~Square() override {
        cout << "Square destructor called." << endl;
    }
};

// int main() { // Tạm thời comment main để tránh xung đột khi gộp code

//     cout << "\n*** Minh họa Đa hình ***" << endl;

//     // Tạo một vector chứa các con trỏ tới lớp cơ sở Shape
//     vector<Shape*> shapes;

//     // Thêm các đối tượng của các lớp kế thừa vào vector
//     // Chúng ta đang lưu con trỏ đến Circle và Square,
//     // nhưng vector chỉ biết chúng là Shape*
//     shapes.push_back(new Circle(5.0));  // Thêm một hình tròn bán kính 5
//     shapes.push_back(new Square(4.0));  // Thêm một hình vuông cạnh 4
//     shapes.push_back(new Circle(3.0));  // Thêm một hình tròn bán kính 3

//     // Lặp qua vector và gọi phương thức calculateArea() cho từng đối tượng
//     cout << "Calculating areas of different shapes:" << endl;
//     for (const auto& shape_ptr : shapes) {
//         // Đây chính là đa hình!
//         // shape_ptr là Shape*, nhưng C++ biết đối tượng thực sự là gì
//         // và gọi đúng phương thức calculateArea() của Circle hoặc Square
//         cout << "  Area: " << shape_ptr->calculateArea() << endl;
//     }

//     // Dọn dẹp bộ nhớ đã cấp phát động
//     cout << "\nCleaning up memory:" << endl;
//     for (const auto& shape_ptr : shapes) {
//         delete shape_ptr; // Hàm hủy ảo đảm bảo hàm hủy của lớp con được gọi
//     }
//     shapes.clear(); // Xóa các con trỏ khỏi vector (không bắt buộc sau delete)


//     cout << "*** Kết thúc Minh họa Đa hình ***" << endl;

//     return 0;
// }

// Tiếp tục sử dụng các lớp đã khai báo ở trên (Animal, Dog, Shape, Circle, Square)
// ... (Bao gồm định nghĩa các lớp Animal, Dog, Shape, Circle, Square ở đây cho đầy đủ) ...

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

using namespace std;

// (Định nghĩa lại các lớp Animal, Dog, Shape, Circle, Square ở đây
// để ví dụ này hoàn chỉnh nếu chạy độc lập, hoặc giả định chúng đã được định nghĩa)

// Hàm sử dụng con trỏ lớp cơ sở - Thể hiện đa hình
void displayArea(const Shape* shape) {
    if (shape) { // Kiểm tra con trỏ có hợp lệ không
        // Gọi phương thức ảo thông qua con trỏ lớp cơ sở
        // Đa hình đảm bảo phương thức đúng của đối tượng thực được gọi
        cout << "Area calculated via displayArea function: " << shape->calculateArea() << endl;
    } else {
        cout << "Cannot display area for a null shape pointer." << endl;
    }
}

// Hàm sử dụng tham chiếu lớp cơ sở - Cũng thể hiện đa hình
void processAnimal(Animal& animal) {
    cout << "Processing animal: " << animal.name << endl;
    // Gọi phương thức ảo thông qua tham chiếu lớp cơ sở
    animal.speak(); // Sẽ gọi speak() của Dog nếu đối tượng thực là Dog
    animal.eat();   // Gọi phương thức không ảo, luôn gọi của lớp Animal (hoặc lớp con nếu override)
    cout << "Processing finished." << endl;
}

int main() {
    cout << "\n*** Minh họa Kế thừa & Đa hình kết hợp trong Hàm ***" << endl;

    // --- Minh họa với Shape và displayArea ---
    Circle smallCircle(2.5);
    Square bigSquare(8.0);

    // Truyền địa chỉ của đối tượng lớp con vào hàm nhận con trỏ lớp cha
    displayArea(&smallCircle); // Hàm displayArea không cần biết nó đang xử lý Circle hay Square
    displayArea(&bigSquare);

    cout << endl; // Xuống dòng

    // --- Minh họa với Animal và processAnimal ---
    Dog maxDog("Max");
    // Animal genericPet("Pet"); // Không thể gọi processAnimal(&genericPet) nếu processAnimal nhận Dog&

    // Truyền đối tượng lớp con vào hàm nhận tham chiếu lớp cha
    processAnimal(maxDog); // Hàm processAnimal không cần biết nó đang xử lý Dog

    // Ví dụ với vector Shape* và hàm displayArea
    vector<Shape*> reportShapes;
    reportShapes.push_back(new Circle(1.0));
    reportShapes.push_back(new Square(10.0));
    reportShapes.push_back(new Circle(5.5));

    cout << "\nProcessing shapes in vector using displayArea function:" << endl;
    for (const auto& s_ptr : reportShapes) {
        displayArea(s_ptr); // Gọi hàm cho từng đối tượng trong vector
    }

    // Dọn dẹp bộ nhớ
    cout << "\nCleaning up memory for reportShapes vector:" << endl;
    for (const auto& s_ptr : reportShapes) {
        delete s_ptr;
    }
    reportShapes.clear();


    cout << "*** Kết thúc Minh họa Kế thừa & Đa hình kết hợp ***" << endl;

    return 0;
}