c++ 封装、继承、重写、重载、多态性

在 C++ 语言中，面向对象编程（OOP）的核心概念包括封装、继承、重写、重载和 多态性。

这些是最基础的知识，现在回顾下。以下是这些概念的详细描述和代码示例：

1. 封装（Encapsulation）

定义：封装是将数据和操作数据的方法（函数）捆绑在一起，形成一个独立的单元（即类）。通过访问控制（如 private、protected、public），封装隐藏了对象的内部实现细节，只暴露必要的接口供外部使用。

示例：

复制代码

#include <iostream>
#include <string>

class Person 
{
private:
    std::string name;  // 私有属性
    int age;           // 私有属性

public:
    // 公有方法：设置姓名
    void setName(const std::string& name) 
    {
        this->name = name;
    }

    // 公有方法：获取姓名
    std::string getName() const 
    {
        return name;
    }

    // 公有方法：设置年龄
    void setAge(int age) 
    {
        if (age > 0) 
        {  // 数据校验
            this->age = age;
        }
    }

    // 公有方法：获取年龄
    int getAge() const 
    {
        return age;
    }
};

int main() 
{
    Person person;
    person.setName("Alice");
    person.setAge(30);

    std::cout << "Name: " << person.getName() << std::endl;  // 输出: Name: Alice
    std::cout << "Age: " << person.getAge() << std::endl;    // 输出: Age: 30

    return 0;
}

2. 继承（Inheritance）

定义：继承允许一个类（子类）基于另一个类（父类）来创建，子类继承父类的属性和方法，并可以扩展或修改它们。

示例：

复制代码

#include <iostream>
#include <string>

// 父类
class Animal 
{
protected:
    std::string name;

public:
    Animal(const std::string& name) : name(name) {}

    void speak() const 
    {
        std::cout << name << " makes a sound." << std::endl;
    }
};

// 子类
class Dog : public Animal 
{
public:
    Dog(const std::string& name) : Animal(name) {}

    // 重写父类方法
    void speak() const 
   {
        std::cout << name << " says Woof!" << std::endl;
    }
};

int main() 
{
    Dog dog("Buddy");
    dog.speak();  // 输出: Buddy says Woof!

    return 0;
}

3. 重写（Override）

定义：重写是指子类重新定义父类中的方法，以改变或扩展其行为。子类的方法名、参数列表必须与父类方法一致。

示例：

复制代码

#include <iostream>
#include <string>

// 父类
class Animal 
{
public:
    virtual void speak() const 
   {
        std::cout << "Animal makes a sound." << std::endl;
    }
};

// 子类
class Cat : public Animal 
{
public:
    void speak() const override
    {  // 重写父类方法
        std::cout << "Cat says Meow!" << std::endl;
    }
};

int main() 
{
    Cat cat;
    cat.speak();  // 输出: Cat says Meow!

    return 0;
}

4. 重载（Overloading）

定义：重载是指在同一个类中定义多个同名方法，但这些方法的参数列表不同（参数类型、数量或顺序）。

示例：

复制代码

#include <iostream>

class Math 
{
public:
    int add(int a, int b) const 
    {
        return a + b;
    }

    double add(double a, double b) const 
    {  // 重载方法
        return a + b;
    }

    int add(int a, int b, int c) const 
    {  // 重载方法
        return a + b + c;
    }
};

int main() 
{
    Math math;
    std::cout << math.add(1, 2) << std::endl;        // 输出: 3
    std::cout << math.add(1.5, 2.5) << std::endl;    // 输出: 4.0
    std::cout << math.add(1, 2, 3) << std::endl;     // 输出: 6

    return 0;
}

5. 多态性（Polymorphism）

定义：多态性是指同一个方法在不同对象中具有不同的行为。多态性通常通过继承和重写实现，允许父类引用指向子类对象，并调用子类重写的方法。

示例：

复制代码

#include <iostream>
#include <memory>

// 父类
class Animal 
{
public:
    virtual void speak() const 
    {  // 虚函数
        std::cout << "Animal makes a sound." << std::endl;
    }
};

// 子类
class Dog : public Animal 
{
public:
    void speak() const override 
    {  // 重写父类方法
        std::cout << "Dog says Woof!" << std::endl;
    }
};

// 子类
class Cat : public Animal 
{
public:
    void speak() const override 
    {  // 重写父类方法
        std::cout << "Cat says Meow!" << std::endl;
    }
};

int main() 
{
    std::unique_ptr<Animal> animal1 = std::make_unique<Dog>();
    std::unique_ptr<Animal> animal2 = std::make_unique<Cat>();

    animal1->speak();  // 输出: Dog says Woof!
    animal2->speak();  // 输出: Cat says Meow!

    return 0;
}

总结

概念	描述	示例
封装	隐藏内部实现，暴露必要接口。	使用 `private` 和 `public` 控制访问权限。
继承	子类复用父类的属性和方法。	`class Dog : public Animal`
重写	子类重新定义父类方法。	使用 `override` 关键字重写虚函数。
重载	同名方法根据参数列表不同实现不同功能。	定义多个同名方法，参数列表不同。
多态性	同一方法在不同对象中有不同行为。	通过虚函数和父类指针实现。

这些概念是 C++ 面向对象编程的核心，掌握它们可以帮助你编写更模块化、可复用和易于维护的代码。