C++奇迹之旅：深入思考拷贝构造函数

---

📝拷贝构造函数

🌠 概念

在现实生活中，可能存在一个与你一样的自己，我们称其为双胞胎。

那在创建对象时，可否创建一个与已存在对象一某一样的新对象呢？

拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。

还是我们熟悉的日期函数：

class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	// 给缺省值
	int _year = 1;
	int _month = 1;
	int _day = 1;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

然后我们定义一个日期对象d1:

int main()
{
	Date d1(2024, 4, 18);
	d1.Print();
	return 0;
}
1
2
3
4
5
6

当你想要一个d2对象与d1的对象数据一样，想拷贝过来怎么做呢？
实现方法：

int main()
{
	Date d2(2024, 4, 9);
	Date d3(d2);
	
	d2.Print();
	d3.Print();
	
	return 0;
}
1
2
3
4
5
6
7
8
9
10

那拷贝构造内部细节怎么做到的呢？我们接着往下看：

拷贝构造函数的定义形式如下:

ClassName(const ClassName& other);
ClassName是类的名称
other是一个引用参数,表示要被拷贝的对象。
const 为了保护原对象other不被更改
1
2
3
4

接上面的日期例子，我们稍稍修改：

class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//ClassName(const ClassName& other);
	Date(const Date& d)
	{	//this==d2
		//this->_year=d1.year;
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	// 给缺省值
	int _year = 1;
	int _month = 1;
	int _day = 1;
};
int main()
{
	Date d1(2024, 4, 18);
	Date d2(d1);
	
	d1.Print();
	d2.Print();
	
	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

这里的this是d2，而d是d1，也就是我们的other

注意：这两种写法是等价的：

// 下面这两种写法是等价的
Date d3(d2);
Date d4 = d2; // 这也是拷贝构造
1
2
3

🌉特征

拷贝构造函数也是特殊的成员函数，其特征如下：

1. 拷贝构造函数是构造函数的一个重载形式。

class Date
{
public:
    // 默认构造函数
    Date()
    {
        _year = 1;
        _month = 1;
        _day = 1;
    }

    // 带参数的构造函数
    Date(int year, int month, int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }

    // 拷贝构造函数
    Date(const Date& other)
    {
        _year = other._year;
        _month = other._month;
        _day = other._day;
    }

    void Print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }

private:
    int _year;
    int _month;
    int _day;
};

int main()
{
    // 使用默认构造函数创建对象
    Date d1;
    d1.Print(); // 输出: 1-1-1

    // 使用带参数的构造函数创建对象
    Date d2(2023, 4, 18);
    d2.Print(); // 输出: 2023-4-18

    // 使用拷贝构造函数创建对象
    Date d3(d2);
    d3.Print(); // 输出: 2023-4-18

    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
43
44
45
46
47
48
49
50
51
52
53
54

2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。

我们先看这个例子：

class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//ClassName(const ClassName& other);
	Date(const Date& d)
	{	//this==d2
		//this->_year=d1.year;
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	// 给缺省值
	int _year = 1;
	int _month = 1;
	int _day = 1;
};
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

这里读文字有点难理解，我们先区别以下两种方式：

void func1(Date d)
{
	d.Print();
}

void func2(Date& d)
{
	d.Print();
}

int main()
{
	Date d1(2024, 4, 18);
	func1(d1);
	func1(d1);

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

进行调试，按F11调试：首先进入func1函数：

但是他却跳转到拷贝构造函数：

拷贝构造函数完了后，才进入到func1函数中：

流程图：

按但是当执行func2时直接能进去func2函数，不需要跳转到拷贝构造函数。

上面是引用拷贝构造函数，如果改为传值会发生无穷递归调用，因为传值传参会调用一个新的拷贝构造

🌠浅拷贝(值拷贝)

若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

class Time
{
public:
	Time()
	{
		_hour = 1;
		_minute = 1;
		_second = 1;
	}
	Time(const Time& t)
	{
		_hour = t._hour;
		_minute = t._minute;
		_second = t._second;
		cout << "Time::Time(const Time&)" << endl;
	}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
private:
	// 基本类型(内置类型)
	int _year = 2024;
	int _month = 4;
	int _day = 18;
	// 自定义类型
	Time _t;
};
int main()
{
	Date d1;

	// 用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数
	// 但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构造函数

	Date d2(d1);
	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

这段代码演示了类的默认构造函数和拷贝构造函数的用法。

1. Time 类:

   • 默认构造函数将 _hour、_minute 和 _second 初始化为 1。
   • 拷贝构造函数会打印一行 "Time::Time(const Time&)"。

2. Date 类:

   • 使用成员初始化列表的方式初始化 _year、_month 和 _day 成员变量。
   • 包含一个 Time 类型的成员变量 _t。

3. main 函数:

   • 创建一个 Date 类型的对象 d1。由于 Date 类没有显式定义构造函数,编译器会自动生成一个默认构造函数,该构造函数会调用 Time 类的默认构造函数来初始化 _t 成员变量。
   • 创建另一个 Date 类型的对象 d2,使用 d1 对象进行拷贝构造。由于 Date 类没有显式定义拷贝构造函数,编译器会自动生成一个默认的拷贝构造函数。这个默认的拷贝构造函数会调用 Time 类的拷贝构造函数来拷贝 _t 成员变量。因此,在创建 d2 对象时,会打印出 "Time::Time(const Time&)"。

对于编译器生成的默认拷贝构造函数里，内置类型是按照字节方式直接拷贝，自定义类型是调用其自己的拷贝构造函数。

当Time的默认构造函数删除时，会发生什么？

class Time
{
public:
	Time(const Time& t)
	{
		_hour = t._hour;
		_minute = t._minute;
		_second = t._second;
		cout << "Time::Time(const Time&)" << endl;
	}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
private:
	// 基本类型(内置类型)
	int _year = 2024;
	int _month = 4;
	int _day = 18;
	// 自定义类型
	Time _t;
};
int main()
{
	Date d1;

	// 用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数
	// 但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构造函数

	Date d2(d1);
	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

出现了尝试引用已删除的函数，这是什么意思？
在 C++ 中,当一个类的成员变量没有默认构造函数时,该类的默认构造函数就会被隐式地标记为已删除。这是因为编译器无法确定如何初始化这些成员变量。
好的,我来解释一下为什么 Date 类的默认构造函数会被标记为已删除(deleted)。

在代码中,Date 类有一个成员变量 _t 是 Time 类型的。而 Time 类没有提供默认构造函数,这就导致 Date 类的默认构造函数无法正确初始化 _t 成员变量。为了解决这个问题,编译器会将 Date 类的默认构造函数标记为已删除(deleted)。这意味着你无法在代码中直接调用 Date 类的默认构造函数,否则会产生编译错误。

如果把Time的构造函数删掉，那么Time的默认构造函数还原，那么编译器就会生成Time的拷贝构造函数来完成拷贝：

注意：在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定义类型是调用其拷贝构造函数完成拷贝的。

🌉深拷贝

编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，还需要自己显式实现吗？当然像日期类这样的类是没必要的。那么下面的类呢？验证一下试试？

// 这里会发现下面的程序会崩溃掉？这里就需要我们以后讲的深拷贝去解决。
typedef int DataType;
class Stack
{
public:
	Stack(size_t capacity = 10)
	{
		_array = (DataType*)malloc(capacity * sizeof(DataType));
		if (nullptr == _array)
		{
			perror("malloc申请空间失败");
			return;
		}
		_size = 0;
		_capacity = capacity;
	}
	void Push(const DataType& data)
	{
		// CheckCapacity();
		_array[_size] = data;
		_size++;
	}
	~Stack()
	{
		if (_array)
		{
			free(_array);
			_array = nullptr;
			_capacity = 0;
			_size = 0;
		}
	}
private:
	DataType* _array;
	size_t _size;
	size_t _capacity;
};
int main()
{
	Stack s1;
	s1.Push(1);
	s1.Push(2);
	s1.Push(3);
	s1.Push(4);
	Stack s2(s1);
	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
43
44
45
46
47

运行截图：



注意：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝。

在 C++ 中,浅拷贝和深拷贝是两种不同的对象复制方式,它们之间有以下区别:

1. 浅拷贝(Shallow Copy):

• 浅拷贝是默认的复制行为,当使用赋值运算符(=)或者拷贝构造函数(T(const T&))复制一个对象时,会发生浅拷贝。
• 浅拷贝只复制对象的成员变量,但不会复制动态分配的内存。也就是说,浅拷贝后的两个对象共享同一块动态内存。
• 如果原对象的动态内存被释放或修改,拷贝对象也会受到影响。这可能会导致严重的内存问题,如野指针、内存泄漏等。

2. 深拷贝(Deep Copy):

• 深拷贝会创建一个新的对象,并将原对象的所有成员变量(包括动态分配的内存)都复制一遍。
• 深拷贝后的两个对象是完全独立的,互不影响。即使原对象的动态内存被释放或修改,拷贝对象也不会受到影响。
• 深拷贝需要自定义拷贝构造函数和赋值运算符,手动分配和复制动态内存。这样可以确保对象之间的独立性。

深拷贝实现：

typedef int DataType;
class Stack
{
public:
	Stack(size_t capacity = 3)
	{
		cout << "Stack(size_t capacity = 3)" << endl;

		_array = (DataType*)malloc(sizeof(DataType) * capacity);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}
		_capacity = capacity;
		_size = 0;
	}

	// Stack st2 = st1;
	Stack(const Stack& st)
	{
		_array = (DataType*)malloc(sizeof(DataType) * st._capacity);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}

		memcpy(_array, st._array, sizeof(DataType) * st._size);

		_size = st._size;
		_capacity = st._capacity;
	}

	void Push(DataType data)
	{
		// CheckCapacity();
		_array[_size] = data;
		_size++;
	}

	bool  Empty()
	{
		return _size == 0;
	}

	DataType Top()
	{
		return _array[_size - 1];
	}
	
	void Pop()
	{
		--_size;
	}

	// 其他方法...
	~Stack()
	{
		cout << "~Stack()" << endl;

		if (_array)
		{
			free(_array);
			_array = NULL;
			_capacity = 0;
			_size = 0;
		}
	}
private:
	DataType* _array;
	int _capacity;
	int _size;
};

int main()
{
	Stack st1;
	st1.Push(1);
	st1.Push(2);

	// 拷贝构造
	Stack st2(st1);

	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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

深拷贝利用栈实现队列的拷贝构造运用：

class MyQueue 
{
private:
	Stack _st1;
	Stack _st2;
	int _size = 0;
};

int main()
{
	MyQueue q1;
	MyQueue q2(q1);

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

🌠拷贝构造函数典型调用场景

1. 使用已存在对象创建新对象:

   MyClass obj1("Hello");
   MyClass obj2(obj1);  // 调用拷贝构造函数
   1
   2

   这种情况下,会调用拷贝构造函数来创建新的 obj2 对象,并将 obj1 的状态复制到 obj2 中。

2. 函数参数类型为类类型对象:

   void printObject(MyClass obj) {
       obj.print();
   }
   
   MyClass obj("Hello");
   printObject(obj);  // 调用拷贝构造函数
   1
   2
   3
   4
   5
   6

   在这个例子中,当 printObject() 函数被调用时,会先调用拷贝构造函数来创建一个临时的 MyClass 对象,并将 obj 的状态复制到这个临时对象上。然后,这个临时对象作为函数参数传递给 printObject()。

3. 函数返回值类型为类类型对象:

   MyClass createObject() {
       MyClass obj("Hello");
       return obj;  // 调用拷贝构造函数
   }
   
   MyClass newObj = createObject();
   1
   2
   3
   4
   5
   6

   在这种情况下,当 createObject() 函数返回时,会调用拷贝构造函数来创建一个新的 MyClass 对象,并将 obj 的状态复制到这个新对象上。这个新对象最终被赋值给 newObj。

🌠应用时效率的思考

为了提高程序效率，一般对象传参时，尽量使用引用类型，返回时根据实际场景，能用引用尽量使用引用。

class Date
{
public:
	Date(int year, int minute, int day)
	{
		cout << "Date(int,int,int):" << this << endl;
	}
	Date(const Date& d)
	{
		cout << "Date(const Date& d):" << this << endl;
	}
	~Date()
	{
		cout << "~Date():" << this << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
Date Test(Date d)
{
	Date temp(d);
	return temp;
}
int main()
{
	Date d1(2022, 1, 13);
	Test(d1);
	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

---

🚩总结

实践中总结:
1、如果没有管理资源，一般情况不需要写拷贝构造，默认生成的拷贝构造就可以。如:Date
2、如果都是自定义类型成员，内置类型成员没有指向资源，也类似默认生成的拷贝构造就可以。如: MyQueue3、一般情况下，不需要显示写析构函数，就不需要写拷贝构造
4、如果内部有指针或者一些值指向资源，需要显示写析构释放，通常就需要显示写构造完成深拷贝。如:Stack Queue List等