1. 深复制与浅复制
1.1 浅复制
浅复制是指将对象的值直接拷贝给新对象，这样新对象和原对象会共享同一个内存地址。当其中一个对象修改了共享的数据时，另一个对象也会受到影响。
【例1-1】使用默认的拷贝构造函数进行浅复制：
#include <iostream> using namespace std; class Person { public: Person() { name = ""; age = 0; } Person(string n, int a) { name = n; age = a; } void display() { cout << "Name: " << name << ", Age: " << age << endl; } private: string name; int age; }; int main() { Person p1("Alice", 20); Person p2 = p1; // 浅复制 p1.display(); // 输出：Name: Alice, Age: 20 p2.display(); // 输出：Name: Alice, Age: 20 // 修改p1的值 p1.name = "Bob"; p1.age = 25; p1.display(); // 输出Name: Bob, Age: 25 p2.display(); // 输出：Name: Bob, Age: 25，受到影响 return 0; }
1.2 深复制
深复制是指创建一个新对象，并将原对象的值拷贝给新对象，新对象拥有属于自己的内存空间。这样，当其中一个对象修改自己的数据时，另一个对象不会受到影响。
【例11-2】使用拷贝构造函数实现深复制：
#include <iostream> using namespace std; class Person { public: Person() { name = ""; age = 0; } Person(string n, int a) { name = n; age = a; } Person(const Person& p) { // 拷贝构造函数 name = p.name; age = p.age; } void display() { cout << "Name: " << name << ", Age: " << age << endl; } private: string name; int age; }; int main() { Person p1("Alice", 20); Person p2 = p1; // 深复制 p1.display(); // 输出：Name: Alice, Age: 20 p2.display(); // 输出：Name: Alice, Age: 20 // 修改p1的值 p1.name = "Bob"; p1.age = 25; p1.display(); // 输出：Name: Bob, Age: 25 p2.display(); // 输出：Name: Alice, Age: 20，不影响 return 0; }
2. 类的组合
2.1 什么是类的组合
类的组合是指一个类中包含另一个类的对象作为其成员变量。通过组合，一个类可以同时包含多个其他类的功能。
【例1-3】类的组合：
#include <iostream> using namespace std; class Engine { public: void start() { cout << "Engine started" << endl; } }; class Car { public: Car() { // 在Car的构造函数中创建Engine对象 engine = new Engine(); } ~Car() { // 在Car的析构函数中释放Engine对象的内存 delete engine; } void startCar() { engine->start(); } private: Engine* engine; }; int main() { Car myCar; myCar.startCar(); // 输出：Engine started return 0; }
2.2 组合类的构造过程
在组合关系中，当一个类对象被创建时，它的成员对象也会被创建。
【例1-4】三角形类：
#include <iostream> using namespace std; class Point { public: Point() { x = 0; y = 0; } Point(int a, int b) { x = a; y = b; } void display() { cout << "Point: (" << x << ", " << y << ")" << endl; } private: int x; int y; }; class Triangle { public: Triangle() { // 构造三个点对象 p1 = Point(0, 0); p2 = Point(0, 0); p3 = Point(0, 0); } Triangle(Point a, Point b, Point c) { // 使用传入的点对象构造三角形 p1 = a; p2 = b; p3 = c; } void display() { cout << "Triangle has 3 points:" << endl; p1.display(); p2.display(); p3.display(); } private: Point p1; Point p2; Point p3; }; int main() { Point a(1, 2); Point b(3, 4); Point c(5, 6); Triangle t1; // 默认构造函数 Triangle t2(a, b, c); // 自定义构造函数 t1.display(); // 输出：Point: (0, 0) Point: (0, 0) Point: (0, 0) t2.display(); // 输出：Point: (1, 2) Point: (3, 4) Point: (5, 6) return 0; }
3. 友元
友元是C++中的一种特殊关系，允许一个类或函数访问另一个类的私有成员。本节将介绍友元函数和友元类的使用。
3.1 友元函数
友元函数是指在一个类中声明的非成员函数，该函数可以访问该类的私有成员。友元函数可以在类的声明中以关键字 friend 进行声明。
【例1-5】求两点之间的距离
下面是一个实例，演示了如何使用友元函数求两点之间的距离：
#include <iostream> #include <cmath> class Point { private: int x; int y; public: Point(int a, int b) { x = a; y = b; } friend float distance(Point p1, Point p2); }; float distance(Point p1, Point p) { int dx =1.x - p2.x; int dy = p1.y - p2.y; return sqrt(dx*dx + dy*dy); } int main() { Point1(3, 4); Point p2(1, 2); float dist = distance(p1, p2); std::cout << "Distance between p1 and p2 is " << dist << std::endl; return 0; }
在上面的例子中，我们定义了一个Point类，其中包含了两个私有成员变量x和y。然后，我们声明了一个友元函数distance，使其能够访问Point类的私有成员。在main函数中创建了两个Point对象1和p2，并通过调用友元函数distance计算出了两点之间的距离。
3.2 友元类
友元类是指能够访问另一个类的私有成员的类。我们可以在类的声明中使用关键字 friend 来声明友元类
【例1-6】友元类的使用
下面是一个示例，演示了如何使用友元：
#include <iostream> class A { private: int x; public: A(int a) { x = a; } friend class B; }; class Bprivate: int y; public: B(int b) { y = b; } void showA(A a) { std::cout << "A's member x is " << a.x << std::endl; } }; int main() { A a(10); B b(20); b.showA(a); return 0; }
在上面的例子中，类A和类B互为友元关系。在类A中，我们声明了类B为友元类，以使其能够访问A的私有成员变量x。类B中的showA函数接受一个A类对象作为参数，并输出A的私有成员x的值。
在main函数中，我们创建了一个A类对象a和一个B类对象b。然后，通过调用b的showA函数，将a传递给它，从而显示了A类的私有成员x的值。
4. 静态成员
4.1 静态数据成员
【例1-7】使用静态数据成员
静态数据成员是类的数据成员，与类的实例对象无关，属于整个类的共享成员。它可以在类定义内部声明为静态成员，然后在类定义外部初始化。通常用于保存所有实例共享的数据。
【例1-7】使用静态数据成员
示例代码如下：
#include <iostream> class MyClass { public: static int data; // 声明静态数据成员 MyClass() { data++; // 在构造函数中修改静态数据成员的值 } }; int MyClass::data = 0; // 静态数据成员的初始化 int main() { MyClass obj1; // 创建第一个实例对象 MyClass obj2; // 创建第二个实例对象 std::cout << "data: " << MyClass::data << std::endl; // 输出静态数据成员的值 return 0; }
上述代码中，我们定义了一个名为MyClass的类，其中包含一个静态数据成员data。在类定义外部，我们对data进行了初始化。
在main函数中，我们创建了两个MyClass的实例对象obj1和obj2。这两个对象共享静态数据成员data。在每个对象的构造函数中，我们对data进行了自增操作。
最后，我们输出了data的值，结果为2，表示两个对象共享了相同的静态数据成员。
4.2 静态成员函数
【例1-8】在Student类中添加静态成员函数
静态成员函数是不依赖于类的实例对象，可以直接通过类名调的成员函数。它不能访问非静态的数据成员和员函数，只能访问静态数据成员和静态成员函数。
【例1-8】在Student类中添加静态成员函数
示例代码如下：
#include <iostream> class Student { private: static int count; // 静态数据成员 public: static void increaseCount() { // 静态成员函数 count++; // 访问静态数据成员 } static int getCount() { return count; } }; int Student::count = 0; // 静态数据成员的初始化 int main() { Student::increaseCount(); // 调用静态成员函数 Student::increaseCount(); std::cout <<count: " << Student::getCount() << std::endl; // 输出静态数据成员的值 return 0; }
上代码中，我们定义了一个名为Student的类，其中包含一个静态数据成员count和两个静态成员函数increaseCount和getCount。
在main函数中，我们通过类名直接调用了increaseCount函数两次，对count进行了两次自增操作。然后，我们调用了getCount函数输出count的值，结果为2。
总结:
静态数据成员是类的共享数据，对于所有实例对象而言，它们拥有相同的值；
静态成员函数是不依赖于实例对象，可以通过类名直接调用的函数。它们只能访问静态数据成员和静态成员函数；
静态成员的声明和初始化需在类的定义外部进行。
5. 常对象与常成员函数
常对象是指在创建对象后，将对象标记为常量，即不允许通过该对象来修改其成员变量的值。常对象的成员函数也被限制为只能调用常成员函数。
5.1 常对象
【例1-9】常对象调用普通成员函数产生的错误
#include<iostream> using namespace std; class MyClass { public: int myVar; MyClass() { myVar = 0; } void modifyVar() { myVar = 10; } }; int main() { const MyClass obj; // 创建一个常对象 obj.modifyVar(); // 错误，常对象不能用普通成员函数 cout << obj.myVar << endl; // 正确，常对象可以读取成员变量的值 return 0; }
运行结果：
error: member function 'void MyClass::modifyVar()' is declared const here void modifyVar() { myVar = 10; } ^
在上述例子中，我们创建了一个常对象 obj，并尝试调用普通成员函数 modifyVar() 。然而，编译器会报错，因为常对象不能调用普通成员函数，只能读取成员变量的值。
5.2 常成员函数
【例11-10】使用常成员函数
#include<iostream> using namespace std; class Circle { private: double radius; public: Circle(double r) { radius = r; } double getArea() const { return 3.14 * radius * radius; } }; int main() { Circle c(5); cout << "Area of circle: " << c.getArea() << endl; // 调用常成员函数获取圆的面积 return 0; }
运行结果：
Area of circle: 78.5
在上述例子中，我们定义了一个 Circle 类，其中的 getArea() 函数被声明为常成员函数。这意味着在该函数内部不会修改任何成员变量的值。在主函数中，我们创建了一个 Circle 对象 c，并通过调用常成员函数 getArea() 获取圆的面积，并将结果输出。
6. 对象数组与对象指针
6.1 对象数组
对象数组是一个由多个相同类型的对象组成的数组。当创建对象数组时，会按照声明顺序自动调用每对象的构造函数进行初始化。
【例1-11】对象数组的应用
#include<iostream> using namespace std; class Point { public: int x, y; Point() { x = 0; y = 0; } void display() { cout << "(" << x << ", " << y << ")" << endl; } }; int main() { Point points[3]; // 创建一个 Point 类型的对象数组 for (int i = 0; i < 3; i++) { points[i].x = i + 1; points[i].y = i + 1; points[i].display(); } return 0; }
运行结果：
(1, 1) (2, 2) (3, 3)
在上述例子中，我们创建了一个 Point 类型的对象数组 points，包含了三个 Point 对象。然后，通过循环为每个对象的成员变量赋值，并调用 display() 函数显示每个对象的坐标。
6.2 对象指针
对象指针是指对象的指针变量。通过对象指针，我们可以访问对象的成员变量和成员函数。
【例1-12】使用对象指针
#include<iostream> using namespace std; class Rectangle { public: int width, height; Rectangle() { width = 0; height = 0; } void setDimensions(int w, int h) { width = w; height = h; } int getArea() { return width * height; } }; int main() { Rectangle rect; // 创建一个 Rectangle 对象 Rectangle* ptr = ▭ // 创建一个指向 Rectangle 对象的指针 ptr->setDimensions(5, 4); // 使用指针调用对象的成员函数 cout << "Area of rectangle: " << ptr->getArea() << endl; // 使用指针访问对象的成员变量 return 0; }
运行结果：
Area of rectangle: 20
在上述例子中，我们创建了一个 Rectangle 对象 rect，并创建了一个指向该对象的指针 ptr。通过指针 ptr，我们可以调用对象的成员函数 setDimensions() ，并访问对象的成员变量 width 和 height。在主函数中，我们使用指针 ptr 分别设置矩形的宽度和高度，并通过指针访问对象的成员变量计算矩形的面积。
