C++封装、继承和多态

C++中的封装、继承和多态是面向对象编程的三大特性，下面我将分别用简单的例子来解释这些概念。

1. 封装 

封装指的是将数据成员和成员函数封装在一起，形成一个类。封装有助于隐藏实现细节，并且保护数据不受外部影响。在C++中，可以通过定义类并将成员声明为private、protected或public来实现封装。

示例代码：

#include <iostream>

 

class BankAccount

{

private:

    double balance; // 数据成员

public:

    BankAccount(double initialBalance) : balance(initialBalance) {} // 构造函数

 

    void deposit(double amount); // 存款

    void withdraw(double amount); // 取款

    double getBalance() const; // 获取余额

};

 

void BankAccount::deposit(double amount)

{

    if (amount > 0)

    {

        balance += amount;

    }

}

 

void BankAccount::withdraw(double amount)

{

    if (amount > 0 && balance >= amount)

    {

        balance -= amount;

    }

}

 

double BankAccount::getBalance() const

{

    return balance;

}

 

int main()

{

    BankAccount account(1000.0);

    account.deposit(500.0);

    account.withdraw(200.0);

    std::cout << "Current Balance: " << account.getBalance() << std::endl;

 

    return 0;

}

2. 继承

继承是指一个类可以从另一个类那里派生出来，继承了基类的所有公共属性和行为。继承支持代码重用和层次分类。

示例代码：

#include <iostream>

 

class Animal

{

public:

    virtual void speak() const = 0; // 纯虚函数

};

 

class Dog : public Animal

{ // 派生类Dog继承自Animal

public:

    void speak() const override

    { // 覆盖基类的虚函数

        std::cout << "Woof!" << std::endl;

    }

};

 

class Cat : public Animal

{ // 派生类Cat继承自Animal

public:

    void speak() const override

    {

        std::cout << "Meow!" << std::endl;

    }

};

 

int main()

{

    Dog dog;

    Cat cat;

 

    dog.speak();

    cat.speak();

 

    return 0;

}

3. 多态

多态意味着一个类的行为可以通过继承和覆写（override）来改变。在C++中，多态通常是通过虚函数实现的。虚函数允许派生类重写基类的方法，从而实现不同的行为。

示例代码：

在上面的继承示例中，我们已经看到了多态的例子。speak()是一个虚函数，在Dog和Cat类中分别有不同的实现。当我们通过指向`Animal`类型的指针或引用调用speak()时，实际调用哪个版本取决于对象的实际类型（动态绑定）。

#include <iostream>

class Animal

{

public:

    virtual ~Animal() {} // 虚析构函数

    virtual void speak() const = 0; // 纯虚函数

};

 

class Dog : public Animal

{

public:

    void speak() const override

{

        std::cout << "Woof!" << std::endl;

    }

};

 

class Cat : public Animal

{

public:

    void speak() const override

{

        std::cout << "Meow!" << std::endl;

    }

};

 

int main()

{

    Animal* myPet = new Dog(); // 动态类型为Dog

    myPet->speak(); // 输出 "Woof!"

    delete myPet; // 因为Animal有虚析构函数，所以这里会调用Dog的析构函数

    myPet = new Cat(); // 动态类型为Cat

    myPet->speak(); // 输出 "Meow!"

    delete myPet; // 同样会调用Cat的析构函数

    return 0;

}

在这个例子中，我们通过Animal*类型的指针来调用speak()方法，实际的行为取决于myPet指向的对象类型。这就是多态性的体现。