详解C++的四大特性（封装，继承，多态，抽象）

C++的四大特性是面向对象编程（OOP）的核心概念，分别是封装、继承、多态和抽象。这些特性共同构成了C++作为面向对象编程语言的基础。

1. 封装（Encapsulation）

• 概念: 封装是将数据和操作数据的方法绑定在一起，限制对数据的直接访问。通过将数据隐藏在类内部，只暴露必要的接口（如public成员函数）来保护对象的内部状态。
• 实现:
  • 在C++中，可以使用访问控制符（private、protected、public）来实现封装。通常，类的数据成员声明为private或protected，而操作数据的方法则声明为public。
• 优点:
  • 提高了代码的安全性，防止了对象的状态被外部代码随意修改。
  • 通过提供清晰的接口，简化了对象的使用，降低了代码的复杂度。

    class Rectangle {
    private:
        double width;
        double height;
    
    public:
        void setDimensions(double w, double h) {
            width = w;
            height = h;
        }
    
        double getArea() {
            return width * height;
        }
    };
    

2. 继承（Inheritance）

• 概念: 继承允许一个类（子类或派生类）从另一个类（父类或基类）获取属性和行为。子类可以继承父类的成员（包括数据成员和成员函数），并可以扩展或重写这些成员。
• 实现:
  • 使用关键字class Derived : public Base来声明继承关系，Derived类将继承Base类的所有公有和受保护成员。
• 优点:
  • 促进了代码的重用，减少了冗余代码。
  • 通过继承，可以创建更为复杂的类层次结构，从而实现更高级的抽象。

    class Shape {
    public:
        void setColor(std::string c) {
            color = c;
        }
    protected:
        std::string color;
    };
    
    class Circle : public Shape {
    public:
        void setRadius(double r) {
            radius = r;
        }
    
        double getArea() {
            return 3.14 * radius * radius;
        }
    private:
        double radius;
    };
    

3. 多态（Polymorphism）

• 概念: 多态允许同一个函数或运算符根据不同的输入或环境表现出不同的行为。C++支持两种多态性：编译时多态性（通过函数重载和模板实现）和运行时多态性（通过虚函数实现）。
• 实现:
  • 运行时多态通过基类中的虚函数来实现，子类可以重写这些虚函数，调用时根据实际的对象类型执行相应的函数版本。
• 优点:
  • 提高了代码的灵活性和可扩展性。
  • 允许以统一的方式处理不同类型的对象，从而简化了代码设计。

    class Animal {
    public:
        virtual void makeSound() {
            std::cout << "Some generic animal sound" << std::endl;
        }
    };
    
    class Dog : public Animal {
    public:
        void makeSound() override {
            std::cout << "Bark" << std::endl;
        }
    };
    
    class Cat : public Animal {
    public:
        void makeSound() override {
            std::cout << "Meow" << std::endl;
        }
    };
    

4. 抽象（Abstraction）

• 概念: 抽象是通过屏蔽复杂的实现细节，只暴露必要的接口来简化对象的使用。抽象允许用户通过接口与对象进行交互，而无需关心对象内部的实现细节。
• 实现:
  • 抽象通常通过抽象类或接口实现。在C++中，含有纯虚函数的类被称为抽象类，不能实例化，只能通过继承并实现其纯虚函数来创建具体的类。
• 优点:
  • 提供了更高层次的控制，使得程序设计更加模块化和灵活。
  • 通过提供清晰的接口，降低了使用和维护代码的难度。

    class Shape {
    public:
        virtual double getArea() = 0; // 纯虚函数
    };
    
    class Rectangle : public Shape {
    public:
        Rectangle(double w, double h) : width(w), height(h) {}
        double getArea() override {
            return width * height;
        }
    private:
        double width, height;
    };
    
    class Circle : public Shape {
    public:
        Circle(double r) : radius(r) {}
        double getArea() override {
            return 3.14 * radius * radius;
        }
    private:
        double radius;
    };
    

 总结来说，封装保护了数据，继承实现了代码重用，多态提供了灵活性，抽象简化了接口。这四大特性相互协作，使得C++能够构建复杂且易于维护的面向对象系统。