C++ 面向对象编程

作为一种面向对象编程语言，C++ 使用对象来模拟现实世界的问题

与过程式编程（其中函数用于对数据执行操作）不同，面向对象编程（OOP）涉及创建同时包含数据和函数的对象。

对象有两个特征：**属性**和**行为**。例如，汽车可以是一个对象。它具有

• **属性** - 品牌、型号、尺寸、里程数等。
• **行为** - 驾驶、加速、停车等。

C++ 类

**类**是**对象**的蓝图。

我们可以将类视为汽车的技术设计（原型）。它包含了关于品牌、型号、里程数等的所有详细信息。然后，我们可以根据这些描述制造不同的汽车。在这里，每一辆不同的汽车就是一个对象。

这方面的一个例子是

class Car {
  public:

    // class data
    string brand, model;
    int mileage = 0;

    // class function
    void drive(int distance) {
        mileage += distance;
    }
};

在上面的代码中，我们使用了 class 关键字来创建一个名为 Car 的类。这里，

• brand 和 model 是用于存储数据的类属性
• drive() 是用于执行某些操作的类函数

public 关键字代表一个**访问修饰符**。要了解更多信息，请访问 C++ 访问修饰符。

C++ 对象

对象是类的实例。

例如，Car 类定义了型号、品牌和里程数。现在，根据定义，我们可以创建对象，如

Car suv;
Car sedan;
Car van;

这里，suv、sedan 和 van 是 Car 类的对象。因此，创建对象的基本语法是

Class_Name object_name;

示例 1：C++ 中的类和对象

#include <iostream>
using namespace std;

class Car {
  public:

    // class data
    string brand, model;
    int mileage = 0;

    // class function to drive the car
    void drive(int distance) {
        mileage += distance;
    }
    
    // class function to print variables
    void show_data() {
        cout << "Brand: " << brand << endl;
        cout << "Model: " << model << endl;
        cout << "Distance driven: " << mileage << " miles" << endl;
    }
};

int main() {
    
    // create an object of Car class
    Car my_car;

    // initialize variables of my_car
    my_car.brand = "Honda";
    my_car.model = "Accord";
    my_car.drive(50);

    // display object variables
    my_car.show_data();

    return 0; 
}

输出

Brand: Honda
Model: Accord
Distance driven: 50 miles

在此程序中，我们创建了一个带有数据成员和成员函数的 Car 类。此外，我们还创建了 Car 类的一个对象 my_car。

请注意，我们已使用点运算符 . 和 my_car 对象来访问类成员。

my_car.brand = "Honda";
my_car.model = "Accord";
my_car.drive(50);

my_car.show_data();

要了解更多信息，请访问我们的 C++ 类和对象教程。

C++ 面向对象编程的基本原则

C++ 面向对象编程的基石原则包括

让我们更详细地探讨这些原则。

1. C++ 封装

在 C++ 中，面向对象编程允许我们将数据成员（如变量、数组等）及其相关函数捆绑到一个实体中。这种编程特性称为封装。

在**示例 1**中，我们将相关的变量 brand、model 和 mileage 与函数 show_data() 捆绑到一个名为 Car 的类中。

class Car {
  public:

    // class data
    string brand;
    string model;
    int mileage = 0;

    // class function
    void show_data() {
        // code
    }
};

封装确保只有类的成员函数才能访问其数据，从而实现数据隐藏。

在 C++ 中，我们使用 private 和 protected 关键字来隐藏数据。相反，对某些类成员使用 public 关键字可以使这些成员可被所有其他函数和类访问。

要了解更多信息，请访问我们的 C++ 封装教程。

2. C++ 抽象

在面向对象编程中，抽象是指向用户显示必要信息的概念，即隐藏程序实现和执行的复杂细节。

例如，让我们考虑 Car 类的一个稍作修改的版本

class Car {
  private:

    // class data
    int speed;

    // class function
    void show_car_status() {
        // code
    }
};

假设我们希望 show_car_status() 函数根据 speed 变量的值显示汽车的状态。

我们可以使用 if...else 语句在 show_car_status() 函数中实现此类条件语句。

void show_car_status() {
    if (speed != 0)
        cout << "The car is being driven." << endl;
    else
        cout << "The car is stationary." << endl;
}

在这里，我们不需要向用户显示我们编写的所有代码来确定汽车是否静止；我们只需要根据其 speed 向他们显示汽车是否正在行驶。

换句话说，我们只向用户提供有用和相关的信息，同时隐藏所有不必要的细节。

这就是 OOP 中的数据抽象。

要了解更多关于抽象的信息，请访问我们的 *C++ 抽象*教程。

注意： 抽象不同于**数据隐藏**。抽象是仅显示相关信息，而数据隐藏是限制对数据成员（变量、数组、结构等）的访问，以便它们无法从类外部访问。

3. C++ 继承

C++ 中的继承允许我们从现有类（基类）创建一个新类（派生类）。

派生类继承了基类的特性，并且可以拥有自己的附加特性。

要了解更多信息，请访问我们的 C++ 继承教程。

示例 2：C++ 中继承的使用

#include <iostream>
using namespace std;

// base class
class Vehicle {
  public:

    string brand;
    
    void show_brand() {
        cout << "Brand: " << brand << endl;
    }    
};

// derived class
class Car : public Vehicle {  
  public:
   
    string model;

    void show_model() {
        cout << "Model: " << model << endl;
    }
};

int main() {
    
    // create an object of Car class
    Car my_car;

    // initialize variables of my_car
    my_car.brand = "Honda";
    my_car.model = "Accord";

    // display variables of my_car
    my_car.show_brand();
    my_car.show_model();

    return 0;    
}

输出

Brand: Honda
Model: Accord

这里，

• Vehicle 是基类。
• Car 是派生类。

派生类继承了基类的特性。我们可以从 brand 变量和 show_brand() 函数中看到这一点，因为 Car 对象 my_car 可以访问它们。

除了基类的特性外，派生类还拥有自己的特性。Car 类的独特特性是

• model - 一个 string 变量
• show_model() - 一个打印 model 变量的函数。

我们还可以看到 Vehicle 类没有被其派生类修改。

要了解更多信息，请访问我们的 C++ 继承教程。

4. C++ 多态

多态是使用通用函数（或运算符）以多种方式的能力。

在 C++ 中，多态通过函数重载、运算符重载、函数覆盖和虚函数来实现。

让我们以函数覆盖为例。

#include <iostream>
using namespace std;

// base class
class Shape {
  public:

    // function of base class
    void shape_name() {
        cout << "Shape" << endl;
    }
};

// derived class
class Square : public Shape {
  public:

    // overriding function of derived class
    void shape_name() {
        cout << "Square" << endl;
    }
};

int main() {

    // create class objects
    Shape shape;
    Square square;

    // call function from Shape class
    shape.shape_name();

    // call function from Square class
    square.shape_name();

    return 0;
}

输出

Shape
Square

这里，

• Shape 是基类。
• Square 是派生类。

这两个类都有一个名为 shape_name() 的函数。但两个类中 shape_name() 函数的主体不同。

当 shape 对象调用 shape_name() 函数时，将执行 Shape 类函数内的代码。

但是，当 square 对象调用 shape_name() 时，将执行 Square 类主体内的代码。

因此，我们通过 C++ 多态以两种不同的方式使用了相同的函数 shape_name()。