C++奇迹之旅：深入思考拷贝构造函数-Toy模板网

这篇具有很好参考价值的文章主要介绍了C++奇迹之旅：深入思考拷贝构造函数。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

C++奇迹之旅：深入思考拷贝构造函数,【C++的奇迹之旅】,c++,java,开发语言,拷贝构造函数,深拷贝与浅拷贝

📝拷贝构造函数

🌠 概念

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

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

拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用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;
};

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

int main()
{
	Date d1(2024, 4, 18);
	d1.Print();
	return 0;
}

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

int main()
{
	Date d2(2024, 4, 9);
	Date d3(d2);
	
	d2.Print();
	d3.Print();
	
	return 0;
}

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

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

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

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

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;
}

这里的this是d2，而d是d1，也就是我们的other
C++奇迹之旅：深入思考拷贝构造函数,【C++的奇迹之旅】,c++,java,开发语言,拷贝构造函数,深拷贝与浅拷贝
注意：这两种写法是等价的：

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

🌉特征

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

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

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;
}

C++奇迹之旅：深入思考拷贝构造函数,【C++的奇迹之旅】,c++,java,开发语言,拷贝构造函数,深拷贝与浅拷贝

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

我们先看这个例子：

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;
};

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

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;
}

进行调试，按F11调试：首先进入func1函数：
C++奇迹之旅：深入思考拷贝构造函数,【C++的奇迹之旅】,c++,java,开发语言,拷贝构造函数,深拷贝与浅拷贝
但是他却跳转到拷贝构造函数：

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

流程图：

按但是当执行func2时直接能进去func2函数，不需要跳转到拷贝构造函数。
C++奇迹之旅：深入思考拷贝构造函数,【C++的奇迹之旅】,c++,java,开发语言,拷贝构造函数,深拷贝与浅拷贝

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

🌠浅拷贝(值拷贝)

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

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;
}

C++奇迹之旅：深入思考拷贝构造函数,【C++的奇迹之旅】,c++,java,开发语言,拷贝构造函数,深拷贝与浅拷贝
这段代码演示了类的默认构造函数和拷贝构造函数的用法。

Time 类:
- 默认构造函数将 _hour、_minute 和 _second 初始化为 1。
- 拷贝构造函数会打印一行 "Time::Time(const Time&)"。
Date 类:
- 使用成员初始化列表的方式初始化 _year、_month 和 _day 成员变量。
- 包含一个 Time 类型的成员变量 _t。
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;
}

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

在代码中,Date 类有一个成员变量 _t 是 Time 类型的。而 Time 类没有提供默认构造函数,这就导致 Date 类的默认构造函数无法正确初始化 _t 成员变量。为了解决这个问题,编译器会将 Date 类的默认构造函数标记为已删除(deleted)。这意味着你无法在代码中直接调用 Date 类的默认构造函数,否则会产生编译错误。
C++奇迹之旅：深入思考拷贝构造函数,【C++的奇迹之旅】,c++,java,开发语言,拷贝构造函数,深拷贝与浅拷贝

如果把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;
}

运行截图：
C++奇迹之旅：深入思考拷贝构造函数,【C++的奇迹之旅】,c++,java,开发语言,拷贝构造函数,深拷贝与浅拷贝

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

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

浅拷贝(Shallow Copy):

浅拷贝是默认的复制行为,当使用赋值运算符(=)或者拷贝构造函数(T(const T&))复制一个对象时,会发生浅拷贝。

浅拷贝只复制对象的成员变量,但不会复制动态分配的内存。也就是说,浅拷贝后的两个对象共享同一块动态内存。

如果原对象的动态内存被释放或修改,拷贝对象也会受到影响。这可能会导致严重的内存问题,如野指针、内存泄漏等。

深拷贝(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;
}

C++奇迹之旅：深入思考拷贝构造函数,【C++的奇迹之旅】,c++,java,开发语言,拷贝构造函数,深拷贝与浅拷贝

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

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

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

	return 0;
}

C++奇迹之旅：深入思考拷贝构造函数,【C++的奇迹之旅】,c++,java,开发语言,拷贝构造函数,深拷贝与浅拷贝

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

使用已存在对象创建新对象:
```
MyClass obj1("Hello");
MyClass obj2(obj1);  // 调用拷贝构造函数
```
这种情况下,会调用拷贝构造函数来创建新的 obj2 对象,并将 obj1 的状态复制到 obj2 中。
函数参数类型为类类型对象:
```
void printObject(MyClass obj) {
    obj.print();
}

MyClass obj("Hello");
printObject(obj);  // 调用拷贝构造函数
```
在这个例子中,当 printObject() 函数被调用时,会先调用拷贝构造函数来创建一个临时的 MyClass 对象,并将 obj 的状态复制到这个临时对象上。然后,这个临时对象作为函数参数传递给 printObject()。
函数返回值类型为类类型对象:
```
MyClass createObject() {
    MyClass obj("Hello");
    return obj;  // 调用拷贝构造函数
}

MyClass newObj = createObject();
```
在这种情况下,当 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;
}

C++奇迹之旅：深入思考拷贝构造函数,【C++的奇迹之旅】,c++,java,开发语言,拷贝构造函数,深拷贝与浅拷贝

🚩总结

实践中总结:
1、如果没有管理资源，一般情况不需要写拷贝构造，默认生成的拷贝构造就可以。如:Date
2、如果都是自定义类型成员，内置类型成员没有指向资源，也类似默认生成的拷贝构造就可以。如: MyQueue3、一般情况下，不需要显示写析构函数，就不需要写拷贝构造
4、如果内部有指针或者一些值指向资源，需要显示写析构释放，通常就需要显示写构造完成深拷贝。如:Stack Queue List等
C++奇迹之旅：深入思考拷贝构造函数,【C++的奇迹之旅】,c++,java,开发语言,拷贝构造函数,深拷贝与浅拷贝文章来源地址https://www.toymoban.com/news/detail-858952.html