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

#include <iostream>
#include <vector> // De luu tru danh sach cac hinh
#include <cmath>  // De su dung M_PI cho hinh tron
#include <memory> // De su dung unique_ptr cho quan ly bo nho

// Lớp cơ sở Shape - Đại diện cho khái niệm chung về hình học
// Đây là một lớp trừu tượng vì có phương thức thuần túy ảo
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 cung cấp định nghĩa của riêng mình.
    // Một lớp có phương thức ảo thuần túy là lớp trừu tượng và không thể tạo đối tượng trực tiếp.
    virtual double calculateArea() const = 0;

    // Phương thức ảo để hủy đối tượng đúng cách khi sử dụng đa hình
    virtual ~Shape() = default; // Sử dụng default để trình biên dịch tạo destructor mặc định
};

// Lớp Circle kế thừa công khai (public) từ Shape
class Circle : public Shape {
private:
    double radius; // Thuoc tinh rieng cua hinh tron
public:
    // Constructor
    Circle(double r) : radius(r) {
        if (radius < 0) radius = 0; // Dam bao ban kinh khong am
    }

    // Ghi đè (override) phương thức calculateArea() từ lớp cơ sở
    double calculateArea() const override {
        return M_PI * radius * radius; // Cong thuc tinh dien tich hinh tron
    }

    // Co the co cac phuong thuc rieng khac cua Circle, vi du getRadius()
    double getRadius() const { return radius; }
};

// Lớp Rectangle kế thừa công khai (public) từ Shape
class Rectangle : public Shape {
private:
    double width;  // Thuoc tinh rieng cua hinh chu nhat
    double height; // Thuoc tinh rieng cua hinh chu nhat
public:
    // Constructor
    Rectangle(double w, double h) : width(w), height(h) {
        if (width < 0) width = 0;
        if (height < 0) height = 0;
    }

    // Ghi đè (override) phương thức calculateArea() từ lớp cơ sở
    double calculateArea() const override {
        return width * height; // Cong thuc tinh dien tich hinh chu nhat
    }

    // Co the co cac phuong thuc rieng khac cua Rectangle
    double getWidth() const { return width; }
    double getHeight() const { return height; }
};

// --- Có thể thêm các lớp hình khác như Triangle, Square, v.v. một cách dễ dàng ---
/*
class Triangle : public Shape {
private:
    double base;
    double height;
public:
    Triangle(double b, double h) : base(b), height(h) {}
    double calculateArea() const override {
        return 0.5 * base * height;
    }
};
*/

int main() {
    // Sử dụng vector để lưu trữ các đối tượng Shape khác nhau
    // Chúng ta lưu trữ con trỏ thông minh (unique_ptr) tới Shape
    // Điều này cho phép chúng ta sử dụng tính năng đa hình
    vector<unique_ptr<Shape>> shapes;

    // Thêm các đối tượng của các lớp con vào vector lưu con trỏ lớp cơ sở
    shapes.push_back(make_unique<Circle>(5.0));        // Một hình tròn bán kính 5
    shapes.push_back(make_unique<Rectangle>(4.0, 6.0)); // Một hình chữ nhật 4x6
    shapes.push_back(make_unique<Circle>(2.5));        // Thêm một hình tròn khác

    // Duyệt qua danh sách các hình và tính diện tích cho từng hình
    // Đây là lúc đa hình phát huy tác dụng!
    cout << "--- Tinh dien tich cac hinh ---" << endl;
    for (const auto& shape : shapes) {
        // Chúng ta gọi phương thức calculateArea() thông qua con trỏ kiểu Shape*.
        // Tuy nhiên, nhờ có từ khóa 'virtual' và tính năng đa hình,
        // C++ sẽ tự động gọi đúng phương thức calculateArea() của lớp con tương ứng
        // (Circle::calculateArea() hoặc Rectangle::calculateArea()).
        cout << "Dien tich: " << shape->calculateArea() << endl;
    }
    cout << "------------------------------" << endl;

    // Khi vector shapes kết thúc phạm vi, các unique_ptr sẽ tự động giải phóng
    // bộ nhớ, gọi đúng destructor của lớp con nhờ virtual destructor trong Shape.

    return 0;
}

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

// Lớp cơ sở Vehicle
class Vehicle {
protected:
    string model = "Unknown";
public:
    Vehicle(const string& m = "Unknown") : model(m) {}

    // Các phương thức chung, có thể là virtual để lớp con ghi đè
    virtual void startEngine() const {
        cout << model << ": Khoi dong dong co chung." << endl;
    }

    virtual void stopEngine() const {
        cout << model << ": Tat dong co chung." << endl;
    }

    // Phương thức virtual destructor là cần thiết để giải phóng bộ nhớ đúng cách
    // khi xóa đối tượng lớp con qua con trỏ lớp cơ sở
    virtual ~Vehicle() = default;
};

// Lớp Car kế thừa từ Vehicle
class Car : public Vehicle {
private:
    int numberOfDoors = 4;
public:
    Car(const string& m, int doors) : Vehicle(m), numberOfDoors(doors) {}

    // Ghi đè phương thức startEngine() cho hành vi đặc trưng hơn
    void startEngine() const override {
        cout << model << ": Khoi dong dong co xe hoi (" << numberOfDoors << " cua)." << endl;
    }

    // Phương thức riêng của Car
    void openTrunk() const {
        cout << model << ": Mo cop xe." << endl;
    }
};

// Lớp Motorcycle kế thừa từ Vehicle
class Motorcycle : public Vehicle {
private:
    bool hasSidecar;
public:
    Motorcycle(const string& m, bool sidecar) : Vehicle(m), hasSidecar(sidecar) {}

    // Ghi đè phương thức startEngine()
     void startEngine() const override {
        cout << model << ": Khoi dong dong co xe may (nghe tieng po lon hon)." << endl;
    }

    // Phương thức riêng của Motorcycle
    void wheelie() const {
        cout << model << ": Bay dau xe!" << endl;
    }
};

// --- Có thể thêm các lớp khác như Truck, Bus, v.v. ---
/*
class Truck : public Vehicle {
private:
    double maxLoad;
public:
    Truck(const string& m, double load) : Vehicle(m), maxLoad(load) {}
    void startEngine() const override {
         cout << model << ": Khoi dong dong co xe tai (tieng to)." << endl;
    }
    void loadCargo(double amount) {
        cout << model << ": Dang chat " << amount << " tan hang." << endl;
    }
};
*/


int main() {
    vector<unique_ptr<Vehicle>> garage;

    // Thêm các loại xe khác nhau vào garage
    garage.push_back(make_unique<Car>("Toyota Camry", 4));
    garage.push_back(make_unique<Motorcycle>("Honda CBR", false));
    garage.push_back(make_unique<Car>("Honda Civic", 5));
    // garage.push_back(make_unique<Truck>("Volvo FH", 30.0)); // Neu co lop Truck

    // Thực hiện hành động chung trên tất cả các phương tiện trong garage
    // Đa hình đảm bảo gọi đúng phương thức startEngine() của từng loại xe
    cout << "--- Khoi dong tat ca xe ---" << endl;
    for (const auto& v : garage) {
        v->startEngine();
    }
    cout << "---------------------------" << endl;

    // Thực hiện hành động riêng biệt (cần kiểm tra loại đối tượng thực tế)
    // Cách phổ biến là sử dụng dynamic_cast
    cout << "\n--- Thuc hien hanh dong rieng biet ---" << endl;
    for (const auto& v : garage) {
        // dynamic_cast tra ve con tro hop le neu ep kieu thanh cong, nguoc lai tra ve nullptr
        Car* car = dynamic_cast<Car*>(v.get());
        if (car) {
            car->openTrunk(); // Chi xe hoi moi co the mo cop
        }

        Motorcycle* moto = dynamic_cast<Motorcycle*>(v.get());
         if (moto) {
            moto->wheelie(); // Chi xe may moi co the bay dau
        }

        // Chú ý: Sử dụng dynamic_cast thường xuyên có thể cho thấy
        // thiết kế của bạn có thể cần xem xét lại để tận dụng đa hình tốt hơn
        // thông qua các phương thức virtual trong lớp cơ sở.
        // Tuy nhiên, đôi khi nó là cần thiết.
    }
     cout << "------------------------------------" << endl;

    // Tắt máy tất cả các xe
    cout << "\n--- Tat dong co tat ca xe ---" << endl;
    for (const auto& v : garage) {
        v->stopEngine(); // Phuong thuc chung
    }
     cout << "-----------------------------" << endl;


    return 0;
}

#include <iostream>
#include <vector>
#include <string>
#include <memory>
#include <iomanip> // De dinh dang dau phay dong

// Lớp cơ sở Employee
class Employee {
protected:
    int id;
    string name;
public:
    // Constructor
    Employee(int i, const string& n) : id(i), name(n) {}

    // Getters chung
    int getId() const { return id; }
    string getName() const { return name; }

    // Phương thức tính lương - Cần triển khai riêng cho từng loại nhân viên
    virtual double calculatePay() const = 0; // Phương thức ảo thuần túy

    // Virtual destructor là rất quan trọng
    virtual ~Employee() = default;
};

// Lớp SalariedEmployee kế thừa từ Employee
class SalariedEmployee : public Employee {
private:
    double annualSalary; // Thu nhap hang nam co dinh
public:
    // Constructor
    SalariedEmployee(int i, const string& n, double salary)
        : Employee(i, n), annualSalary(salary) {}

    // Triển khai calculatePay cho nhân viên ăn lương cố định (tính lương tháng)
    double calculatePay() const override {
        return annualSalary / 12.0; // Chia luong nam cho 12 thang
    }

    // Co the them getter/setter cho annualSalary neu can
    double getAnnualSalary() const { return annualSalary; }
};

// Lớp HourlyEmployee kế thừa từ Employee
class HourlyEmployee : public Employee {
private:
    double hourlyRate;  // Muc luong theo gio
    int hoursWorked;    // So gio da lam trong ky tinh luong
public:
    // Constructor
    HourlyEmployee(int i, const string& n, double rate, int hours)
        : Employee(i, n), hourlyRate(rate), hoursWorked(hours) {}

    // Triển khai calculatePay cho nhân viên theo giờ
    double calculatePay() const override {
        return hourlyRate * hoursWorked; // Luong = So gio * Luong moi gio
    }

    // Phuong thuc de cap nhat so gio lam
    void setHoursWorked(int hours) {
        if (hours >= 0) {
            hoursWorked = hours;
        } else {
            cerr << "So gio lam khong hop le!\n";
        }
    }

    double getHourlyRate() const { return hourlyRate; }
    int getHoursWorked() const { return hoursWorked; }
};

// --- Có thể thêm các loại nhân viên khác như Manager (có thêm bonus), CommissionEmployee, v.v. ---
/*
class Manager : public SalariedEmployee {
private:
    double monthlyBonus;
public:
    Manager(int i, const string& n, double salary, double bonus)
        : SalariedEmployee(i, n, salary), monthlyBonus(bonus) {}

    double calculatePay() const override {
        // Lương quản lý = Lương cố định + Bonus
        return SalariedEmployee::calculatePay() + monthlyBonus;
    }
};
*/

int main() {
    // Sử dụng vector lưu trữ con trỏ thông minh tới Employee
    vector<unique_ptr<Employee>> staff;

    // Thêm các loại nhân viên khác nhau vào danh sách
    staff.push_back(make_unique<SalariedEmployee>(101, "Nguyen Van A", 60000.0)); // Luong nam 60k
    staff.push_back(make_unique<HourlyEmployee>(102, "Tran Thi B", 15.0, 160));    // 15$/gio, 160 gio
    staff.push_back(make_unique<SalariedEmployee>(103, "Le Van C", 72000.0)); // Luong nam 72k
    // staff.push_back(make_unique<Manager>(104, "Pham Thi D", 80000.0, 500.0)); // Neu co lop Manager

    // Duyệt qua danh sách nhân viên và tính lương cho từng người
    // Nhờ đa hình, chúng ta chỉ cần gọi calculatePay() chung
    cout << fixed << setprecision(2); // Dinh dang hien thi so thap phan

    cout << "--- Bang luong thang nay ---" << endl;
    for (const auto& emp : staff) {
        // C++ tu dong goi phuong thuc calculatePay() dung voi loai doi tuong thuc te
        cout << "ID: " << emp->getId()
                  << ", Ten: " << emp->getName()
                  << ", Luong: " << emp->calculatePay() << " $" << endl;
    }
    cout << "---------------------------" << endl;

    // Ví dụ cập nhật thông tin riêng của từng loại (cần dynamic_cast hoặc cách khác)
     cout << "\n--- Cap nhat du lieu rieng biet (vd: gio lam) ---" << endl;
     for (const auto& emp : staff) {
        // Kiểm tra nếu đối tượng hiện tại là HourlyEmployee
        HourlyEmployee* hourlyEmp = dynamic_cast<HourlyEmployee*>(emp.get());
        if (hourlyEmp) {
            cout << "Cap nhat gio lam cho " << hourlyEmp->getName() << endl;
            hourlyEmp->setHoursWorked(185); // Cap nhat so gio lam
            cout << "Luong thang sau cap nhat gio lam: " << hourlyEmp->calculatePay() << " $" << endl;
        }
     }
     cout << "-----------------------------------------------" << endl;


    return 0;
}