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

#include <iostream>
#include <string>

// Định nghĩa một Class tên là Dog (Chó)
class Dog {
public: // Phần công khai (public), có thể truy cập từ bên ngoài class
    // Thuộc tính (Data Members)
    string name; // Tên của con chó
    int age;          // Tuổi của con chó

    // Phương thức (Member Functions)
    void bark() { // Hàm để con chó sủa
        cout << name << " (" << age << " tuổi) says Woof! Woof!" << endl;
    }

    void eat(string food) { // Hàm để con chó ăn
        cout << name << " is eating " << food << "." << endl;
    }
}; // Kết thúc định nghĩa class bằng dấu chấm phẩy ;

int main() {
    // Tạo một Object (thể hiện) tên là myDog từ Class Dog
    Dog myDog;

    // Truy cập và gán giá trị cho các thuộc tính của object
    myDog.name = "Buddy";
    myDog.age = 3;

    // Gọi các phương thức (hành động) của object
    myDog.bark();
    myDog.eat("kibble");

    // Tạo một object khác từ cùng Class Dog
    Dog anotherDog;
    anotherDog.name = "Max";
    anotherDog.age = 5;
    anotherDog.bark();

    return 0;
}

#include <iostream>
#include <string>

class Dog {
private: // Các thuộc tính này chỉ có thể truy cập từ bên trong Class Dog
    string name;
    int age;

public: // Các phương thức này có thể truy cập từ bên ngoài Class
    // Constructor - một phương thức đặc biệt được gọi khi tạo Object
    // Chúng ta sẽ nói kỹ hơn sau, tạm hiểu là dùng để khởi tạo Object
    Dog(string n, int a) {
        // Có thể thực hiện kiểm tra hợp lệ ở đây
        name = n;
        if (a > 0) {
            age = a;
        } else {
            age = 0; // Giá trị mặc định nếu tuổi không hợp lệ
            cerr << "Lỗi: Tuổi không hợp lệ. Đặt tuổi là 0." << endl;
        }
    }

    // Getter cho name
    string getName() const { // const: phương thức này không thay đổi trạng thái object
        return name;
    }

    // Setter cho name
    void setName(string n) {
        name = n;
    }

    // Getter cho age
    int getAge() const {
        return age;
    }

    // Setter cho age - có kiểm tra hợp lệ
    void setAge(int a) {
        if (a > 0) {
            age = a;
        } else {
             cerr << "Lỗi: Tuổi không hợp lệ. Tuổi không thay đổi." << endl;
        }
    }

    // Phương thức khác vẫn ở public
    void bark() const {
        cout << name << " (" << age << " tuổi) says Woof!" << endl;
    }
};

int main() {
    // Tạo object sử dụng constructor
    Dog myDog("Buddy", 3);

    // myDog.name = "New Name"; // Lỗi compile! Không thể truy cập private member trực tiếp

    // Lấy tên thông qua getter
    cout << "Tên của chó: " << myDog.getName() << endl;

    // Thay đổi tên thông qua setter
    myDog.setName("Buddy the Great");
    cout << "Tên mới: " << myDog.getName() << endl;

    // Thay đổi tuổi thông qua setter (hợp lệ)
    myDog.setAge(4);
    cout << "Tuổi mới: " << myDog.getAge() << endl;

    // Thử thay đổi tuổi không hợp lệ
    myDog.setAge(-2); // Sẽ in ra thông báo lỗi từ setter

    myDog.bark();

    return 0;
}

#include <iostream>
#include <string>

class Dog {
private:
    string name;
    int age;
    // Các chi tiết triển khai nội bộ bị ẩn đi
    double volume; // Độ to của tiếng sủa

    // Một phương thức nội bộ phức tạp (ví dụ)
    void generateSoundWaves() const {
        cout << "Generating complex sound waves at volume " << volume << "... ";
        // ... hàng trăm dòng code xử lý âm thanh phức tạp ...
        cout << "Done!" << endl;
    }

public:
    Dog(string n, int a, double v = 1.0) : name(n), age(a), volume(v) {} // Constructor

    string getName() const { return name; }
    int getAge() const { return age; }
    void setVolume(double v) { volume = v; }


    // Phương thức công khai, là giao diện trừu tượng
    void bark() const {
        // Người dùng chỉ gọi bark(), không cần biết generateSoundWaves() hoạt động thế nào
        generateSoundWaves(); // Gọi phương thức nội bộ
        cout << name << " (" << age << " tuổi) says Woof! (at volume " << volume << ")" << endl;
    }
};

int main() {
    Dog myDog("Max", 5, 0.8);

    // Người dùng tương tác thông qua giao diện công khai
    myDog.bark(); // Họ chỉ cần biết myDog.bark() sẽ làm con chó sủa

    // Họ không cần biết (và cũng không thể truy cập nếu nó là private)
    // cách âm thanh được tạo ra bên trong generateSoundWaves()

    return 0;
}

#include <iostream>
#include <string>
#include <vector> // Để minh họa đa hình sau

// Lớp cơ sở (Base Class)
class Animal {
private:
    // Thuộc tính private, chỉ truy cập được trong lớp Animal
    string species; // Loại động vật (ví dụ: "Dog", "Cat")

protected:
    // Thuộc tính protected, truy cập được trong lớp Animal và các lớp kế thừa
    string name; // Tên của động vật

public:
    // Constructor của lớp cơ sở
    Animal(string s, string n) : species(s), name(n) {
        cout << "Đã tạo một Animal: " << name << " (" << species << ")" << endl;
    }

    // Phương thức công khai của lớp cơ sở
    void eat() const {
        cout << name << " the " << species << " is eating." << endl;
    }

    // Phương thức ảo (Virtual method) - Quan trọng cho Đa hình runtime
    // Sẽ nói kỹ hơn ở phần Đa hình
    virtual void makeSound() const {
        cout << name << " the " << species << " makes a generic sound." << endl;
    }

    // Virtual Destructor - Quan trọng khi làm việc với đa hình và con trỏ
    // Giúp giải phóng bộ nhớ đúng cách khi sử dụng con trỏ lớp cơ sở
    virtual ~Animal() {
         cout << "Đã hủy một Animal: " << name << " (" << species << ")" << endl;
    }
};

// Lớp dẫn xuất (Derived Class) kế thừa từ Animal
class Dog : public Animal { // Kế thừa công khai (public inheritance)
private:
    string breed; // Giống chó (thuộc tính riêng của Dog)

public:
    // Constructor của lớp Dog
    // Phải gọi constructor của lớp cơ sở Animal sử dụng cú pháp khởi tạo danh sách (initializer list)
    Dog(string n, string b) : Animal("Dog", n), breed(b) {
        cout << "Đã tạo một Dog: " << name << " (" << breed << ")" << endl;
    }

    // Phương thức riêng của lớp Dog
    void bark() const {
        // Có thể truy cập thuộc tính 'protected' name từ lớp cơ sở
        cout << name << " the " << breed << " says Woof! Woof!" << endl;
    }

    // Ghi đè (Override) phương thức makeSound() từ lớp cơ sở
    // Từ khóa 'override' (C++11 trở lên) giúp kiểm tra xem phương thức này
    // có thực sự ghi đè một phương thức ảo trong lớp cha hay không.
    void makeSound() const override {
         cout << name << " the " << breed << " says Woof! (override)" << endl;
    }

    // Destructor của lớp Dog
    ~Dog() {
         cout << "Đã hủy một Dog: " << name << " (" << breed << ")" << endl;
    }
};

// Lớp dẫn xuất khác
class Cat : public Animal {
public:
    Cat(string n) : Animal("Cat", n) {
        cout << "Đã tạo một Cat: " << name << endl;
    }

    void meow() const {
        cout << name << " the Cat says Meow!" << endl;
    }

     void makeSound() const override {
         cout << name << " the Cat says Meow! (override)" << endl;
    }

    ~Cat() {
         cout << "Đã hủy một Cat: " << name << endl;
    }
};


int main() {
    // Tạo một object của lớp dẫn xuất Dog
    Dog myDog("Buddy", "Golden Retriever");

    // myDog kế thừa phương thức eat() từ lớp Animal
    myDog.eat(); // Output: Buddy the Dog is eating.

    // myDog có phương thức riêng bark()
    myDog.bark(); // Output: Buddy the Golden Retriever says Woof! Woof!

    // myDog gọi phương thức makeSound đã được ghi đè
    myDog.makeSound(); // Output: Buddy the Golden Retriever says Woof! (override)

    cout << "\n--- Minh hoa ke thua va IS-A ---\n";

    // Có thể sử dụng con trỏ hoặc tham chiếu tới lớp cơ sở (Animal)
    // để trỏ tới object của lớp dẫn xuất (Dog hoặc Cat)
    Animal* animalPtr1 = &myDog; // Pointer tới Animal trỏ tới object Dog
    Cat myCat("Whiskers");
    Animal& animalRef1 = myCat; // Reference tới Animal tham chiếu tới object Cat

    // Khi gọi phương thức THÔNG THƯỜNG qua con trỏ/tham chiếu lớp cơ sở,
    // phương thức của lớp cơ sở được gọi (early binding / compile-time)
    animalPtr1->eat(); // Vẫn gọi Animal::eat()
    animalRef1.eat(); // Vẫn gọi Animal::eat()

    // Khi gọi phương thức VIRTUAL qua con trỏ/tham chiếu lớp cơ sở,
    // phương thức của lớp CỤ THỂ (lớp dẫn xuất) được gọi (late binding / runtime)
    animalPtr1->makeSound(); // Gọi Dog::makeSound() nhờ virtual!
    animalRef1.makeSound(); // Gọi Cat::makeSound() nhờ virtual!


    // Ghi chú về memory management: Dùng con trỏ thô cần cẩn thận.
    // Trong C++, thường dùng smart pointers (như unique_ptr, shared_ptr)
    // để quản lý bộ nhớ tốt hơn, đặc biệt với đa hình.
    // Destructor ảo là cần thiết để đảm bảo destructor của lớp dẫn xuất được gọi đúng.

    return 0;
}

#include <iostream>
#include <vector>
#include <memory> // Để sử dụng unique_ptr, giúp quản lý bộ nhớ tốt hơn

// Lớp cơ sở Animal (từ ví dụ Kế thừa, có virtual makeSound)
class Animal {
protected:
    string name;
public:
    Animal(string n) : name(n) {}

    // Phương thức ảo (có thể được ghi đè ở lớp con)
    virtual void makeSound() const {
        cout << name << " makes a generic sound." << endl;
    }

    // Destructor ảo rất quan trọng khi dùng đa hình với con trỏ
    virtual ~Animal() {
        cout << "Destructing Animal: " << name << endl;
    }
};

// Lớp dẫn xuất Dog (ghi đè makeSound)
class Dog : public Animal {
public:
    Dog(string n) : Animal(n) {}

    // Ghi đè phương thức ảo makeSound
    void makeSound() const override {
        cout << name << " says Woof!" << endl;
    }

    ~Dog() override { // Cũng nên dùng override cho destructor ảo
        cout << "Destructing Dog: " << name << endl;
    }
};

// Lớp dẫn xuất Cat (ghi đè makeSound)
class Cat : public Animal {
public:
    Cat(string n) : Animal(n) {}

    // Ghi đè phương thức ảo makeSound
    void makeSound() const override {
        cout << name << " says Meow!" << endl;
    }

    ~Cat() override {
         cout << "Destructing Cat: " << name << endl;
    }
};

int main() {
    // Tạo các đối tượng cụ thể
    Dog myDog("Buddy");
    Cat myCat("Whiskers");

    cout << "\n--- Minh hoa Da hinh Runtime ---\n";

    // Sử dụng con trỏ lớp cơ sở để trỏ đến các đối tượng lớp dẫn xuất
    Animal* animalPtr1 = &myDog; // Con trỏ Animal trỏ đến Dog
    Animal* animalPtr2 = &myCat; // Con trỏ Animal trỏ đến Cat

    // Gọi phương thức makeSound() thông qua con trỏ lớp cơ sở
    // Nhờ từ khóa 'virtual' trong lớp Animal, C++ biết cần gọi
    // phiên bản makeSound() của lớp thực tế mà con trỏ đang trỏ tới
    animalPtr1->makeSound(); // Output: Buddy says Woof! (gọi Dog::makeSound)
    animalPtr2->makeSound(); // Output: Whiskers says Meow! (gọi Cat::makeSound)

    cout << "\n--- Minh hoa Da hinh voi Collection (vector) ---\n";

    // Một ví dụ mạnh mẽ hơn về Đa hình: sử dụng một collection
    // chứa các đối tượng thuộc các lớp dẫn xuất khác nhau thông qua con trỏ/tham chiếu lớp cơ sở.
    // Sử dụng unique_ptr để tự động quản lý bộ nhớ
    vector<unique_ptr<Animal>> farm;

    farm.push_back(make_unique<Dog>("Rocky"));
    farm.push_back(make_unique<Cat>("Mittens"));
    farm.push_back(make_unique<Dog>("Spike"));
    farm.push_back(make_unique<Cat>("Leo"));

    // Lặp qua collection và gọi phương thức makeSound() cho từng đối tượng
    // Mỗi đối tượng sẽ thực hiện hành động makeSound() của riêng loại của nó
    // mà không cần biết cụ thể nó là Dog hay Cat
    cout << "Tieng keu cua cac dong vat trong trang trai:" << endl;
    for (const auto& animal : farm) {
        animal->makeSound(); // Đa hình đang hoạt động ở đây!
    }
    // Khi vector farm kết thúc phạm vi, unique_ptr sẽ tự động gọi destructor
    // và nhờ virtual destructor trong Animal, destructor đúng của Dog/Cat sẽ được gọi.

    return 0;
}