STL容器与默认拷贝构造函数,默认赋值函数

最新推荐文章于 2023-02-16 17:27:16 发布
最新推荐文章于 2023-02-16 17:27:16 发布
阅读量4.3k 收藏 5
点赞数
分类专栏： C/C++ 文章标签： STL容器 默认拷贝构造函数 默认赋值函数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/suxinpingtao51/article/details/38731075
版权

默认拷贝构造函数和默认赋值函数这两个函数都采用“按成员拷贝”的默认方式来实现。也就是说：它们会依次调用每个数据成员的默认拷贝函数和默认赋值函数，除非为它们显示定义了新的构造函数和赋值函数；如此递归下去，真到所有成员都是基本类型为止。

但是要知道，基本类型变量（包括指针）的拷贝和赋值实际上是按bit位进行拷贝的，因此假如类中有指针成员，这两个默认函数的执行结果将是两个对象中的对应指针成员指向相同的对象，而这在一般情况下关非所期望的，在这种情况下这两个函数有可能出现隐含错误，甚至出现严重错误，在含有指针成员的类中，我们一定要显示实现这两个函数。（在实践中，我发现若是你在一个DLL库中动态分配了一个类对象内存，而该对象的内存释放只在库被释放的时候，你才会去释放该块类对象的内存，可库被加载进来的生命周期跟你的主程序是一样的，这种情况下，你也不用自己去实现拷贝构造函数，即使你自己去实现了，也不用在拷贝构造函数中另外new一块改类对象的内存。）

 

拷贝构造函数：只有单个形参,并且该形参时本类对象的引用(经常使用const修饰)的构造函数.
默认拷贝构造函数:
在没有定义拷贝构造函数的时候,编译器将自动生成一个
默认拷贝构造函数将执行的操作：对该类的每个成员执行初始化

(对于基础类型直接赋值,对于其所有对象成员逐个调用其对应的拷贝构造函数，即使有STL对象数据成员也是一样的，因为string，vector之类的STL对象都是有自己的拷贝构造函数 和 =赋值函数的)


特别的:倘若一个类拥有数组成员,默认拷贝构造函数将复制数组(即复制数组中的每一个元素).
自定义拷贝构造函数:
只包含对象成员或基础类型成员的类(即不包含指针),无需显示定义拷贝构造函数.使用默认的即可.
包含指针成员的类,倘若必须自定义拷贝构造函数(或者定义未定义的私有拷贝构造函数以放置被外部拷贝). 倘若要在拷贝构造函数时需要做一些操作也应该自定义拷贝构造函数.
禁止调用拷贝构造函数:
将拷贝构造函数显示声明为私有.(如果连友元和成员函数也禁止执行拷贝操作,则声明拷贝构造为私有后不进行定义)

 

=重载:
类的默认赋值函数:
在没有重载赋值函数时,编译器将自动生成一个.
默认赋值函数将执行的操作:对该类的每个成员执行赋值操作(对于基础类型直接赋值,对于其所有对象成员逐个调用其对应的赋值函数.)倘若一个类拥有数组成员,默认赋值函数将对数组中的每一个元素执行赋值操作.
[自定义赋值函数]的条件和拷贝构造函数相同.
[禁止赋值函数]的方法同样和拷贝构造函数相同.

 

赋值和拷贝构造经常一起使用,通常在用到其中一个时,几乎肯定同时会用到另一个

 

 

以下内容是转载他处的，链接：点击打开链接

所有容器提供的都是“value语意”而非“reference语意”。容器内进行元素的安插操作时，内部实施的是拷贝操作，置于容器内。因此STL容器的每一个元素都必须能够拷贝。---<<C++标准程序库>> 侯捷、孟岩译 p144页原文 

以vector为例，往Vector中（实际上所有STL容器都是这样）放元素，Vector会调用元素类的拷贝构造函数生成的副本，当Vector走出生存期时()，会自动调用其中每个元素的析构函数。比如，如果 vector<myclass> a，然后a.push_back(b);push_back其实是调用myclass的拷贝构造函数将参数b拷贝进去的。由于vector是自动管理的，出了a的作用域外，a会自动消失释放内存。之前push_back到a里面的数据b通过调用b.~myclass()释放内存。

[cpp] view plain copy print ?
  1. #include <vector>    
  2. using namespace std;   
  3.   
  4. class CDemo{   
  5. public:   
  6. CDemo():str(NULL){}   
  7. ~CDemo(){if(str) delete [] str;}   
  8. char *str;   
  9. };   
  10.   
  11. int main()   
  12. {   
  13. CDemo d1;   
  14. d1.str = new char[32];   
  15. strcpy(d1.str, "trend micro");   
  16.   
  17. vector <CDemo> *a1 = new vector <CDemo>();   
  18. a1 -> push_back(d1);   
  19.   
  20. delete a1;   
  21. return 0;   
  22. }   
#include <vector> 
using namespace std; 

class CDemo{ 
public: 
CDemo():str(NULL){} 
~CDemo(){if(str) delete [] str;} 
char *str; 
}; 

int main() 
{ 
CDemo d1; 
d1.str = new char[32]; 
strcpy(d1.str, "trend micro"); 

vector <CDemo> *a1 = new vector <CDemo>(); 
a1 -> push_back(d1); 

delete a1; 
return 0; 
}

1. vector <CDemo> *a1 = new vector <CDemo>(); a1是new出来的，所以必须要手工delete.这是对a1本身而言，而与a1内存储的数据无关。
2. a1 -> push_back(d1); 这部操作比较复杂，因为你的vector是存储类，而不是类指针。但是push_back的参数是引用，所以不需要创建d1的拷贝（也就不需要调用拷贝构造）作为参数传递给push_back。但是在push_back中，会创建d1的拷贝d1_1（需要调用拷贝构造），d1_1是存储在a1管理的内存中。
3. delete a1; a1中存有d1_1，所以会删除d1_1，自然会调用d1_1的析构函数。
4. 在main中return 0, d1被自动删除，此时调用d1的析构函数。
5. 因为class CDemo没有拷贝构造函数，所以创建拷贝时只是简单的把新对象中每个成员变量的值设置成与原来的对象相等。相当于运行memcpy。这时问题就来了，因为你的一个成员是char *str; 这样d1,d1_1的str都是指向同一个地址。所以只有第一次调用CDemo的析构函数时能运行正确，以后的都会出错。因为一个地址只能释放一次。

解决办法是定义自己的拷贝构造函数实现深拷贝：

[cpp] view plain copy print ?
  1. #include <iostream>   
  2. #include <fstream>   
  3. #include <vector>   
  4. using namespace std;  
  5.   
  6. ofstream out("test.out");  
  7. class CDemo{  
  8. public:  
  9.     CDemo():str(NULL){  
  10.         out << "constructor is called" << endl;  
  11.     }  
  12.     CDemo(const CDemo &cd)  
  13.     {  
  14.         out << "copy constructor is called" << endl;  
  15.         this->str = new char[strlen(cd.str)+1];  
  16.         strcpy(str, cd.str);  
  17.     }  
  18.   
  19.     ~CDemo(){  
  20.         if(str){  
  21.             out << "destructor is called" << endl;  
  22.             delete[] str;  
  23.         }  
  24.     }  
  25.     char *str;  
  26. };  
  27.   
  28. int main()  
  29. {  
  30.     vector <CDemo> *a1 = new vector <CDemo>();  
  31.     a1 -> reserve(1);  
  32.     out << a1 -> capacity() << endl;  
  33.       
  34.     CDemo d1;  
  35.     d1.str = new char[32];  
  36.     strcpy(d1.str, "trend micro1");  
  37.     out << "/" << endl;  
  38.     a1->push_back(d1);  
  39.     out << "/" << endl;  
  40.     CDemo d2;  
  41.     d2.str = new char[32];  
  42.     strcpy(d2.str, "trend micro2");  
  43.     out << "/" << endl;  
  44.     a1->push_back(d2);  
  45.     out << "/" << endl;  
  46.     delete a1;  
  47.   
  48.     return 0;  
  49. }  
#include <iostream>
#include <fstream>
#include <vector>
using namespace std;

ofstream out("test.out");
class CDemo{
public:
	CDemo():str(NULL){
		out << "constructor is called" << endl;
	}
	CDemo(const CDemo &cd)
	{
		out << "copy constructor is called" << endl;
		this->str = new char[strlen(cd.str)+1];
		strcpy(str, cd.str);
	}

	~CDemo(){
		if(str){
			out << "destructor is called" << endl;
			delete[] str;
		}
	}
	char *str;
};

int main()
{
	vector <CDemo> *a1 = new vector <CDemo>();
	a1 -> reserve(1);
	out << a1 -> capacity() << endl;
	
	CDemo d1;
	d1.str = new char[32];
	strcpy(d1.str, "trend micro1");
	out << "/" << endl;
	a1->push_back(d1);
	out << "/" << endl;
	CDemo d2;
	d2.str = new char[32];
	strcpy(d2.str, "trend micro2");
	out << "/" << endl;
	a1->push_back(d2);
	out << "/" << endl;
	delete a1;

	return 0;
}

1
constructor is called
/
copy constructor is called
/
constructor is called
/
copy constructor is called
copy constructor is called         //搬运之前的元素
destructor is called                    //之前的元素被析构
/
destructor is called                    //析构容器中所有对象
destructor is called
destructor is called                    //析构CDemo d1
destructor is called                   //析构CDemo d2

可以看到，再加入第二个对象的时候，拷贝构造函数被调用的两次，这是因为，在第一次push_back时，vector的capacity是1,是正常调用一次拷贝构造；而第二次push_back时，会发现容量不够了，stl会重新分配一个old_size的两倍的空间，除了新push进来的数据会放在这个新空间，调用一次拷贝构造，原来已经有的数据也要搬过来的，就又要调用拷贝构造。如果把a1 -> reserve(1);修改为a1 -> reserve(2);保证第二次时也有足够的空间，那么程序的运行结果为：

2
constructor is called
/
copy constructor is called
/
constructor is called
/
copy constructor is called
/
destructor is called
destructor is called
destructor is called
destructor is called
为了进一步验证空间重新分配对对象拷贝的影响，看下面的例子：

[cpp] view plain copy print ?
  1. #include <iostream>   
  2. #include <fstream>   
  3. #include <vector>   
  4. using namespace std;  
  5.   
  6. ofstream out("test.out");  
  7. class CDemo{  
  8. public:  
  9.     CDemo():str(NULL){  
  10.         out << "constructor is called" << endl;  
  11.     }  
  12.     CDemo(const CDemo &cd)  
  13.     {  
  14.         out << "copy constructor is called" << endl;  
  15.         this->str = new char[strlen(cd.str)+1];  
  16.         strcpy(str, cd.str);  
  17.     }  
  18.   
  19.     ~CDemo(){  
  20.         if(str){  
  21.             out << "destructor is called" << endl;  
  22.             delete[] str;  
  23.         }  
  24.     }  
  25.     char *str;  
  26. };  
  27.   
  28. int main()  
  29. {  
  30.     vector <CDemo> *a1 = new vector <CDemo>();  
  31.     a1 -> reserve(1);  
  32.       
  33.     for(int i = 1; i < 5; i ++){  
  34.         out << "/" << endl;  
  35.         out << i << endl;  
  36.         CDemo d;  
  37.         d.str = new char[32];  
  38.         strcpy(d.str, "trend micro1" + i);  
  39.         out << "begin to push_back" << endl;  
  40.         out << "the vector capacity is " << a1 -> capacity() << endl;  
  41.         a1->push_back(d);  
  42.     }  
  43.     out << "/" << endl;  
  44.     delete a1;  
  45.   
  46.     return 0;  
  47. }  
#include <iostream>
#include <fstream>
#include <vector>
using namespace std;

ofstream out("test.out");
class CDemo{
public:
	CDemo():str(NULL){
		out << "constructor is called" << endl;
	}
	CDemo(const CDemo &cd)
	{
		out << "copy constructor is called" << endl;
		this->str = new char[strlen(cd.str)+1];
		strcpy(str, cd.str);
	}

	~CDemo(){
		if(str){
			out << "destructor is called" << endl;
			delete[] str;
		}
	}
	char *str;
};

int main()
{
	vector <CDemo> *a1 = new vector <CDemo>();
	a1 -> reserve(1);
	
	for(int i = 1; i < 5; i ++){
        out << "/" << endl;
        out << i << endl;
        CDemo d;
		d.str = new char[32];
		strcpy(d.str, "trend micro1" + i);
		out << "begin to push_back" << endl;
		out << "the vector capacity is " << a1 -> capacity() << endl;
		a1->push_back(d);
	}
	out << "/" << endl;
	delete a1;

	return 0;
}

程序的运行结果：

/
1
constructor is called
begin to push_back
the vector capacity is 1
copy constructor is called
destructor is called
/
2
constructor is called
begin to push_back
the vector capacity is 1
copy constructor is called
copy constructor is called          //搬运之前的元素1
destructor is called                     //之前的元素被析构
destructor is called                     //CDemo d临时对象
/
3
constructor is called
begin to push_back
the vector capacity is 2
copy constructor is called
copy constructor is called         //搬运之前的元素1
copy constructor is called         //搬运之前的元素2
destructor is called                    //之前的元素1被析构
destructor is called                    //之前的元素2被析构
destructor is called                    //CDemo d临时对象
/
4
constructor is called
begin to push_back
the vector capacity is 4
copy constructor is called         //不需要搬运，第三次时容量已经变成4
destructor is called                    //CDemo d临时对象
/
destructor is called                    //析构容器中所有对象
destructor is called
destructor is called
destructor is called
可以看到，容量的确是按照两倍的空间递增，并且原来已经有的数据要搬过来，就要调用拷贝构造。所以为了程序的效率，最好一开始就用reserve确定vector的大小，避免之后动态扩展，搬运原有数据引起拷贝构造的调用。

 

STL容器与拷贝构造函数
和大黄的博客
09-04 1万+
所有容器提供的都是“value语意”而非“reference语意”。容器内进行元素的安插操作时，内部实施的是拷贝操作，置于容器内。因此STL容器的每一个元素都必须能够拷贝。---> 侯捷、孟岩译 p144页原文  以vector为例，往Vector中（实际上所有STL容器都是这
STL与拷贝构造函数
salcab的专栏
02-26 317
今天在网上看到“对需要保存到容器中的对象的类型来说，每个类都必须至少实现拷贝构造函数，最好还能重载赋值操作符。”这样一句话。不甚明白，于是写了个实验程序。 #include #include #include using namespace std; class base { public: base(char *n) { if(n != NULL) { m_
C++空类
marken
05-27 2254
<br />定义一个空的C++类，例如<br />class Empty<br /> {<br /> }<br />一个空的class在C++编译器处理过后就不再为空，编译器会自动地为我们声明一些member function，一般编译过去就相当于<br />class Empty<br /> {<br /> public:<br /> Empty(); // 缺省构造函数<br /> Empty( const Empty& ); // 拷贝构造函数<br /> ~Empty(); // 析
类的默认赋值函数
EagerYoungMinds
05-31 1898
类，不仅会产生默认构造函数、复制构造函数、析构函数，还会产生默认赋值函数。其形式如：T& operator=(const T& t)； 事例如下：  #include using namespace std; class Complex{ public: // double real, imag;  Complex(int i)  {   cout   real = i; i
C++拷贝构造函数在STL中的高级应用：算法和容器的深度拷贝
[C++拷贝构造函数在STL中的高级应用：算法和容器的深度拷贝](https://img-blog.csdnimg.cn/f11f4a1967284e75aa656098fcbdc7b7.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1...
c++ 赋值运算符重载和拷贝构造函数区别以及不写时可能引发的问题
struggle6688的专栏
04-18 641
一、赋值运算符重载和拷贝构造函数区别 #include <iostream> using namespace std; class Element { private: int *m_pdata; public: Element(int data) { cout << "构造函数" << endl; m_pdata = new int(data...
STL容器深浅拷贝 容器共性机制
log_Li的博客
07-13 116
STL 容器共性机制 STL 容器所提供的都是值(value)寓意，而非引用(reference)寓意，也就是说当我们给 容器中插入元素的时候，容器内部实施了拷贝动作，将我们要插入的元素再另行拷贝一份放 入到容器中，而不是将原数据元素直接放进容器中，也就是说**我们提供的元素必须能够被拷 贝。**  除了queue 和stack 之外，每个容器都提供可返回迭代器的函数，运用返回的迭代器就可以访问元素。  通常STL不会抛出异常，需要使用者传入正确参数。  每个容器都提供了一个默认的构造函数和默认的拷贝
STL中常用的容器和函数
默的博客
01-23 1764
所有容器都支持的方法 栈（stack） 循环队列（queue） 优先队列（priority_queue） 有序集合（set） 向量（vector） 字典（map） 对组（pair） 字符串（string） sort函数 max、m C++的标准模板库（Standard Template Library， 简称STL）是一个容器和算法的类库，比较常用的容器有stack、queue、priorty_queue、set等，比较常用的算法有sort等 所有容器都支持的方法 方法 描述 示例 时间复杂度...
STL容器和算法函数表
06-06
### STL容器和算法函数表详解 #### 一、Vector类的主要成员 `vector<T>`是C++标准模板库(STL)中的动态数组实现，能够自动调整其大小，提供了高效的随机访问能力，是C++中最常用的数据结构之一。 ##### 容器属性 -...
C++：类的六个默认函数之一 —— 赋值重载
AngelDg的博客
03-12 2355
文章目录运算符重载概念赋值运算符重载要点总结 运算符重载概念 C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。 函数名字为:关键字operator后面接需要重载的运算符符号。 函数原型:返回值类型 operator操作符(参数列表) 注意: 不能通过连接其他符号来创建新的操作符:比...
c++中的赋值函数
热门推荐
专注于C/C++/Linux领域创作
03-22 1万+
在c++中，对于任意一个类Class A，如果程序员不显示的声明和定义上述函数，C++编译器将会自动的为A产生4个public inline 的默认函数，这4个函数最常见的形式为： A() //默认构造函数 A（const A&) //默认拷贝构造函数 ~A() //默认析构函数 A& operator = (const A &) //默认赋值函数。 其中只有默认赋值函数...
类默认成员函数（赋值拷贝函数）
最新发布
m0_69126768的博客
02-16 91
赋值拷贝函数
C++的四个默认函数（构造函数，析构函数，拷贝函数，赋值函数）
花狗Fdog的博客
02-23 9715
文章目录一. 构造函数二. 析构函数三. 拷贝构造函数1.浅拷贝2.深拷贝四. 赋值函数 在C++中，对于一个类，C++的编译器都会为这个类提供四个默认函数，分别是： A() //默认构造函数 ~A() //默认析构函数 A（const A&) //默认拷贝构造函数 A& operator = (const A &) //默认赋值函数。 这四个函数如果我们不自行定义，将由编译器自动生成这四个缺省的函数，下面让我们来看看这四个函数（重点是后
默认拷贝构造函数和默认赋值函数
对酒当歌
09-27 2568
当一个类中有动态分配内存时，应当自己定义拷贝构造函数和赋值函数 class A { int *p; public: A() { p = new int[10]; } ~A() { delete p; } }; void f(A x) { cout "Yes" << endl; } int main
[STL]深拷贝和浅拷贝问题（内存泄露+内存未释放+调用拷贝构造的五种情况）
weixin_44972997的博客
03-29 3502
通过三段代码详细解释浅拷贝和深拷贝带来的问题和解决方案，例如`内存泄露` or `内存未释放`。明确重载拷贝构造函数的重要性，以及出现拷贝构造函数的几种情况。
C++基础之四个默认函数(构造，析构，拷贝构造，赋值运算符重载)
T、的博客
12-12 633
作用： 拿一个已存在的对象来给另一个已存在的对象赋值 const 1.防止修改实参的值 2.接收隐式生成临时对象 CGoods& operator=(const CGoods& rhs) { if(this == &rhs)//如果相等便是相同对象 { return *this; } mname = rhs.mname; mprice = rhs.mprice...
默认拷贝构造函数，默认赋值函数的考察
riverking123的专栏
01-28 478
class A { public: A(int x) {     y = x+1; } void Print() {    cout } private:           int y; }; void main() {       A a1 = 0;       A a2(a1);       a2.Print(); } 求这段代码输出
C++初级主题--(6)赋值函数
哒哒的博客
02-05 789
一.默认赋值函数的一般形式赋值语句其实是对“=”进行重载。 Test& operator=(const Test &t) { cout<<"赋值函数："<<this<<"="<<&t<<endl; if(this != &t) data = t.data; return *this; }二.详解赋值函数赋
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值