十四天学会C++之第四天（面向对象编程基础）

类和对象是什么？

在C++中，类是一种用户定义的数据类型，它可以包含数据成员（也就是属性）和成员函数（也就是方法）。类是一种模板或蓝图，用于创建具体的对象。

对象是类的实例，它是根据类的定义创建的，可以用来表示现实世界中的各种事物。对象具有类定义的属性和行为。

面向对象编程思想

面向对象编程（OOP）是一种编程范式，强调将现实世界的概念映射到类和对象上。这种思想使得代码更加模块化、可维护性更强，更容易理解。

举个例子，如果我们要编写一个程序来模拟汽车的行为，我们可以创建一个名为Car的类。这个类可以有属性，如颜色、速度等，以及方法，如加速、刹车等。然后，我们可以根据这个类创建多个汽车对象，每个对象都代表现实世界中的一辆汽车。

C++中的类和对象示例

类和对象的基本概念：

#include 
using namespace std;

// 定义一个类
class Car {
public:
    // 属性
    string color;
    int speed;

    // 方法
    void start() {
        cout << "Car started." << endl;
    }

    void accelerate() {
        speed += 10;
        cout << "Accelerating. Speed: " << speed << " km/h" << endl;
    }
};

int main() {
    // 创建两个Car对象
    Car car1;
    Car car2;

    // 设置属性
    car1.color = "Red";
    car1.speed = 0;

    car2.color = "Blue";
    car2.speed = 0;

    // 调用方法
    car1.start();
    car1.accelerate();

    car2.start();
    car2.accelerate();

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

运行结果：

在示例中，我们定义了一个Car类，它有两个属性（color和speed）和两个方法（start和accelerate）。然后，我们创建了两个Car对象car1和car2，并分别设置了它们的属性，最后调用了对象的方法。

成员变量和成员函数是什么？

在C++类中，成员变量是用来存储对象的属性或数据的变量。它们描述了对象的状态。成员变量也被称为类的数据成员。

成员函数是与类相关联的函数，它们定义了对象的行为和操作。成员函数也被称为类的成员操作或方法。

声明和定义成员变量

在C++中，成员变量通常在类的声明部分进行声明，然后在类的定义部分进行定义。

class Student {
public:
    // 声明成员变量
    string name;
    int age;

    // 其他成员函数...
};

// 在类的定义部分初始化成员变量
Student::Student() {
    name = "John";
    age = 20;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

在示例中，我们声明了两个成员变量name和age，然后在类的定义部分使用构造函数对它们进行初始化。

声明和定义成员函数

成员函数通常在类的声明部分进行声明，然后在类的定义部分进行定义。

class Student {
public:
    // 成员函数的声明
    void setName(string n);
    void setAge(int a);

    // 其他成员变量...

private:
    string name;
    int age;
};

// 成员函数的定义
void Student::setName(string n) {
    name = n;
}

void Student::setAge(int a) {
    age = a;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

在示例中，我们声明了两个成员函数setName和setAge，然后在类的定义部分进行了定义。这些成员函数用于设置成员变量name和age的值。

使用成员变量和成员函数

一旦类的成员变量和成员函数被声明和定义，我们可以通过创建类的对象来使用它们。例如：

int main() {
    Student student1;
    student1.setName("Alice");
    student1.setAge(22);

    // 其他操作...

    return 0;
}
1
2
3
4
5
6
7
8
9

在示例中，我们创建了一个Student对象student1，然后使用成员函数setName和setAge来设置对象的属性。

构造函数和析构函数是什么？

构造函数是一种特殊的成员函数，用于在对象被创建时初始化对象的成员变量。构造函数的名称与类名相同，它没有返回值。在C++中，每个类都可以有一个或多个构造函数。

析构函数也是一种特殊的成员函数，用于在对象被销毁时清理对象的资源。析构函数的名称与类名相同，但前面有一个波浪号（~）。在C++中，每个类都可以有一个析构函数。

构造函数的示例

下面是一个构造函数的示例：

class Student {
public:
    // 构造函数
    Student(string n, int a) {
        name = n;
        age = a;
    }

    // 其他成员函数...

private:
    string name;
    int age;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14

在示例中，我们定义了一个接受两个参数的构造函数，用于初始化name和age成员变量。

析构函数的示例

下面是一个析构函数的示例：

class Student {
class Student {
public:
    // 构造函数
    Student(string n, int a) {
        name = n;
        age = a;
    }

    // 其他成员函数...

private:
    string name;
    int age;
};public:
    // 构造函数
    Student(string n, int a) {
        name = n;
        age = a;
    }

    // 析构函数
    ~Student() {
        // 清理资源的代码
    }

    // 其他成员函数...

private:
    string name;
    int age;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

在示例中，我们定义了一个析构函数，它可以用于清理对象的资源，例如释放动态分配的内存。

使用构造函数和析构函数

构造函数在创建对象时自动调用，而析构函数在对象被销毁时自动调用。例如：

int main() {
    // 创建对象时调用构造函数
    Student student1("Alice", 22);

    // 对象销毁时调用析构函数
    // 不需要手动调用析构函数，它会自动执行清理操作

    return 0;
}
1
2
3
4
5
6
7
8
9

封装、继承和多态是什么？

这三个概念是面向对象编程的核心，它们分别是：

1. 封装（Encapsulation）：封装是将数据和操作数据的方法捆绑在一起的概念。类中的成员变量和成员函数可以被封装在一起，从外部只能访问类的公有接口，而不能直接访问内部的实现细节。

2. 继承（Inheritance）：继承允许一个类继承另一个类的属性和方法。子类可以继承父类的成员，并且可以添加新的成员或修改继承的成员。这提高了代码的重用性和可维护性。

3. 多态（Polymorphism）：多态允许不同的对象对相同的消息作出不同的响应。这意味着具有不同类的对象可以对相同的方法调用做出不同的响应。多态性通过虚函数和抽象类实现。

封装的示例

下面是一个封装的示例：

class Circle {
public:
    // 构造函数
    Circle(double r) {
        radius = r;
    }

    // 计算面积的方法
    double calculateArea() {
        return 3.14159 * radius * radius;
    }

private:
    double radius;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

在示例中，radius成员变量被封装在Circle类中，外部代码无法直接访问它。

继承的示例

下面是一个继承的示例：

class Animal {
public:
    void eat() {
        cout << "Animal is eating." << endl;
    }
};

class Dog : public Animal {
public:
    void bark() {
        cout << "Dog is barking." << endl;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13

在示例中，Dog类继承了Animal类的eat方法，同时添加了自己的bark方法。

多态的示例

下面是一个多态的示例：

class Shape {
public:
    virtual void draw() {
        cout << "Drawing a shape." << endl;
    }
};

class Circle : public Shape {
public:
    void draw() override {
        cout << "Drawing a circle." << endl;
    }
};

class Square : public Shape {
public:
    void draw() override {
        cout << "Drawing a square." << endl;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

在示例中，Shape类定义了一个虚函数draw，而Circle和Square类分别重写了这个函数。当我们通过基类指针调用draw方法时，具体执行哪个子类的方法取决于对象的实际类型。

类和对象的概念

在C++中，类是一种用户定义的数据类型，它用于封装数据和操作数据的方法。类定义了一种对象的结构，包括它的属性（成员变量）和行为（成员函数）。对象是类的实例，是具体的数据。

让我们从一个简单的示例开始：

// 定义一个类
class Student {
public:
    // 成员变量
    string name;
    int age;

    // 成员函数
    void display() {
        cout << "Name: " << name << ", Age: " << age << endl;
    }
};

int main() {
    // 创建一个Student对象
    Student s;

    // 设置对象的属性
    s.name = "Alice";
    s.age = 20;

    // 调用对象的方法
    s.display();

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

在示例中，我们定义了一个Student类，它有两个成员变量name和age，以及一个成员函数display用于显示学生信息。然后，我们创建了一个Student对象s，设置了对象的属性并调用了成员函数。

示例代码

• 创建一个类Car，包含成员变量brand（品牌）和price（价格），以及成员函数showInfo用于显示车辆信息。

class Car {
public:
    string brand;
    double price;

    void showInfo() {
        cout << "Brand: " << brand << ", Price: $" << price << endl;
    }
};
1
2
3
4
5
6
7
8
9

• 在main函数中，创建两个Car对象并设置它们的属性，然后调用showInfo方法显示信息。

int main() {
    Car car1;
    car1.brand = "Toyota";
    car1.price = 25000.0;

    Car car2;
    car2.brand = "Honda";
    car2.price = 22000.0;

    car1.showInfo();
    car2.showInfo();

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

练习题

1. 创建一个类Rectangle表示矩形，包含成员变量width（宽度）和height（高度），以及成员函数calculateArea用于计算矩形的面积。
2. 在main函数中，创建一个Rectangle对象，设置其宽度和高度，然后调用calculateArea方法计算并显示面积。

创建一个Rectangle类表示矩形时，首先要定义类的成员变量和成员函数。在main函数中，我们可以创建一个Rectangle对象并调用其成员函数来计算面积并显示。

#include 

using namespace std;

// 创建一个类 Rectangle 表示矩形
class Rectangle {
public:
    // 成员变量，表示矩形的宽度和高度
    double width;
    double height;

    // 成员函数，用于计算矩形的面积
    double calculateArea() {
        return width * height;
    }
};

int main() {
    // 创建一个 Rectangle 对象
    Rectangle myRectangle;

    // 设置矩形的宽度和高度
    myRectangle.width = 5.0;
    myRectangle.height = 3.0;

    // 调用 calculateArea 方法计算面积
    double area = myRectangle.calculateArea();

    // 显示矩形的面积
    cout << "矩形的面积是: " << area << endl;

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

运行结果：

解答说明：

1. 首先定义一个Rectangle类，其中包含了两个成员变量width和height，以及一个成员函数calculateArea用于计算矩形的面积。
2. 在main函数中，创建一个名为myRectangle的Rectangle对象。
3. 设置myRectangle对象的width和height属性为5.0和3.0。
4. 调用calculateArea方法计算矩形的面积，并将结果存储在area变量中。
5. 最后，使用cout输出矩形的面积。

运行这段代码，你将得到输出结果：矩形的面积是: 15。

一个简单的类和对象，并在类中定义成员函数来执行操作。可以根据这个示例来创建更复杂的类和对象，并定义更多的成员函数来完成不同的任务。

创建一个Rectangle类表示矩形时，首先要定义类的成员变量和成员函数。在main函数中，可以创建一个Rectangle对象并调用其成员函数来计算面积并显示。

#include 

using namespace std;

// 创建一个类 Rectangle 表示矩形
class Rectangle {
public:
    // 成员变量，表示矩形的宽度和高度
    double width;
    double height;

    // 成员函数，用于计算矩形的面积
    double calculateArea() {
        return width * height;
    }
};

int main() {
    // 创建一个 Rectangle 对象
    Rectangle myRectangle;

    // 设置矩形的宽度和高度
    myRectangle.width = 5.0;
    myRectangle.height = 3.0;

    // 调用 calculateArea 方法计算面积
    double area = myRectangle.calculateArea();

    // 显示矩形的面积
    cout << "矩形的面积是: " << area << endl;

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

运行结果：

解答说明：

1. 首先定义了一个Rectangle类，其中包含了两个成员变量width和height，以及一个成员函数calculateArea用于计算矩形的面积。
2. 在main函数中，创建一个名为myRectangle的Rectangle对象。
3. 设置myRectangle对象的width和height属性为5.0和3.0。
4. 调用calculateArea方法计算矩形的面积，并将结果存储在area变量中。
5. 最后，使用cout输出矩形的面积。

运行这段代码，你将得到输出结果：矩形的面积是: 15。

创建一个简单的类和对象，并在类中定义成员函数来执行操作。可以根据这个示例来创建更复杂的类和对象，并定义更多的成员函数来完成不同的任务。