C++的面向对象特性

C++的面向对象特性

当谈到C++的面向对象特性时，通常涉及到封装（Encapsulation）、继承（Inheritance）、多态（Polymorphism）、抽象（Abstraction）等概念。下面是这些概念的简要解释以及英文翻译，每个概念都附有简单的例子。

1. 封装（Encapsulation）：

   • 定义： 封装是将数据和操作数据的方法捆绑在一起的概念，同时隐藏了数据的具体实现细节。
   • 英文： Encapsulation
   • 例子：

     class Circle {
     private:
         double radius;
     
     public:
         void setRadius(double r) {
             if (r > 0) {
                 radius = r;
             }
         }
     
         double getArea() {
             return 3.14 * radius * radius;
         }
     };

2. 继承（Inheritance）：

   • 定义： 继承允许一个类（子类）从另一个类（父类）继承属性和方法，并且可以扩展或修改它们。
   • 英文： Inheritance
   • 例子：

     class Shape {
     public:
         virtual double getArea() const = 0;
     };
     
     class Circle : public Shape {
     private:
         double radius;
     
     public:
         Circle(double r) : radius(r) {}
     
         double getArea() const override {
             return 3.14 * radius * radius;
         }
     };

3. 多态（Polymorphism）：

   • 定义： 多态允许使用一个统一的接口来表示不同的对象，即一个对象可以被看作是多个类型。
   • 英文： Polymorphism
   • 例子：

     class Shape {
     public:
         virtual double getArea() const = 0;
     };
     
     class Circle : public Shape {
     private:
         double radius;
     
     public:
         Circle(double r) : radius(r) {}
     
         double getArea() const override {
             return 3.14 * radius * radius;
         }
     };
     
     void printArea(const Shape& shape) {
         cout << "Area: " << shape.getArea() << endl;
     }

4. 抽象（Abstraction）：

   • 定义： 抽象是简化复杂系统的过程，通过隐藏不必要的细节来聚焦于关键的概念。
   • 英文： Abstraction
   • 例子：

     class Shape {
     public:
         virtual double getArea() const = 0;
     };
     
     class Circle : public Shape {
     private:
         double radius;
     
     public:
         Circle(double r) : radius(r) {}
     
         double getArea() const override {
             return 3.14 * radius * radius;
         }
     };

其他概念

1. 重载（Overloading）：

   • 定义： 重载允许在同一作用域内定义具有相同名称但参数列表不同的多个函数或运算符。编译器根据上下文调用适当的函数或运算符。
   • 英文： Overloading
   • 例子：

     class MathOperations {
     public:
         int add(int a, int b) {
             return a + b;
         }
     
         double add(double a, double b) {
             return a + b;
         }
     
         // 函数重载
         // 上面的 add 函数和这个 add 函数在参数列表不同
         int add(int a, int b, int c) {
             return a + b + c;
         }
     };
     
     // 运算符重载
     class Complex {
     private:
         double real;
         double imag;
     
     public:
         Complex() : real(0), imag(0) {}
     
         Complex operator+(const Complex& other) const {
             Complex result;
             result.real = real + other.real;
             result.imag = imag + other.imag;
             return result;
         }
     };

在上面的例子中，MathOperations 类演示了函数重载，而 Complex 类演示了运算符重载。函数和运算符可以根据参数的数量或类型进行重载。