C++中的封装、继承、多态理解

C++是一门支持面向对象编程（Object-Oriented Programming，简称OOP）的语言。在OOP中，封装、继承、多态是三个重要的概念。下面我们详细讲解每个概念及其在C++中的应用。

封装（Encapsulation）

封装是通过将一个类的数据和方法包装在一起来隐藏类的实现细节。也就是说，封装可以通过保护数据和方法的访问级别来实现隐藏实现细节的目的。

在C++中，我们使用访问级别修饰符（Access Specifier）来控制数据和方法的访问级别。C++中的三种访问级别修饰符包括public、private和protected。

• public：公共访问级别，可以在类的内部和外部被访问。
• private：私有访问级别，只能在类的内部被访问，外部无法访问。
• protected：保护访问级别，可以在类的内部和派生类中被访问。派生类是指由该类派生出的子类。

以下是一个封装的示例：

class Student {
private:
    char* m_name;
    int m_age;
public:
    void set_name(const char* name) {
        m_name = new char[strlen(name) + 1];
        strcpy(m_name, name);
    }
    void set_age(int age) {
        m_age = age;
    }
    const char* get_name() const {
        return m_name;
    }
    int get_age() const {
        return m_age;
    }
};

int main() {
    Student s;
    s.set_name("Tom");
    s.set_age(20);
    std::cout << "Name: " << s.get_name() << ", Age: " << s.get_age() << std::endl;
    return 0;
}

在上面的示例中，我们使用private修饰符将成员变量m_name和m_age隐藏，然后使用public修饰符封装了四个公共的访问方法：set_name()、set_age()、get_name()和get_age()。通过这些公共的方法可以访问和修改成员变量m_name和m_age的值，而不能直接访问或修改它们。这样就保证了成员变量的安全性和高可维护性。

继承（Inheritance）

继承是一种面向对象的编程概念，它允许我们通过创建一个新的类来扩展或修改现有类的特性。新创建的类被称为派生类（Derived Class），现有的类被称为基类（Base Class）。

在C++中，我们使用关键字class后面加上冒号来指定一个类的继承关系。可以使用public、private和protected修饰符来控制派生类对基类成员的访问权限。

以下是一个继承的示例：

class Shape {
protected:
    double m_width;
    double m_height;
public:
    Shape(double width = 0, double height = 0): m_width(width), m_height(height) {}
    virtual double area() const = 0;
};

class Rectangle: public Shape {
public:
    Rectangle(double width = 0, double height = 0): Shape(width, height) {}
    double area() const {
        return m_width * m_height;
    }
};

int main() {
    Shape* s = new Rectangle(10, 20);
    std::cout << "Area: " << s->area() << std::endl;
    delete s;
    return 0;
}

在上面的示例中，我们定义了一个基类Shape，包含两个成员变量m_width和m_height，还有一个抽象方法area()。然后我们定义了一个派生类Rectangle，并继承了Shape类。Rectangle类实现了area()方法的具体计算方法。在main函数中，我们使用动态多态（后面会具体讲解）创建了一个Shape指针，并将其指向Rectangle对象，最后调用area()方法计算面积。通过使用继承，我们可以轻松地扩展Shape类的功能，而不必对现有代码进行修改。

多态（Polymorphism）

多态是OOP中的重要概念，它允许程序员使用一种统一的方式来处理同一类对象的不同形态。多态可以在编译时（静态多态）或运行时（动态多态）进行处理。

C++的多态通过虚函数（Virtual Function）来实现。虚函数是一个存在于基类中的特殊函数，它在派生类中可以被重写并具有不同的实现方式，而且根据实际调用的对象类型来决定执行哪个实现。如果一个虚函数在基类中已经被声明，派生类中可以使用override关键字来显式地标识这是一个重写的函数。

以下是一个多态的示例：

class Shape {
protected:
    double m_width;
    double m_height;
public:
    Shape(double width = 0, double height = 0): m_width(width), m_height(height) {}
    virtual double area() const = 0;
};

class Rectangle: public Shape {
public:
    Rectangle(double width = 0, double height = 0): Shape(width, height) {}
    double area() const override {
        return m_width * m_height;
    }
};

class Triangle: public Shape {
public:
    Triangle(double width = 0, double height = 0): Shape(width, height) {}
    double area() const override {
        return m_width * m_height / 2;
    }
};

int main() {
    Shape* s1 = new Rectangle(10, 20);
    Shape* s2 = new Triangle(10, 20);
    std::cout << "Rectangle Area: " << s1->area() << std::endl;
    std::cout << "Triangle Area: " << s2->area() << std::endl;
    delete s1;
    delete s2;
    return 0;
}

在上面的示例中，我们定义了基类Shape、派生类Rectangle和Triangle，并重写了基类中的虚函数area()。在main函数中，我们使用动态多态分别创建了Rectangle和Triangle对象，并调用它们的area()方法进行面积计算。通过使用虚函数和动态多态，我们可以在运行时决定调用哪个对象的哪个实现，从而实现多态。

以上就是C++中封装、继承、多态三个面向对象编程概念的详细讲解，希望对你有所帮助。