当前位置: 58彩票app下载 > 计算机网络 > 正文

深拷贝与浅拷贝

时间:2019-09-24 00:53来源:计算机网络
 转自 C++拷贝构造函数(深拷贝与浅拷贝),拷贝构造函数  转自 一. 哪些是拷贝构造函数   对此普通品种的对象的话,它们中间的复制是很简短的,比如: int a=88; int b=a;    而类对

 转自

C++拷贝构造函数(深拷贝与浅拷贝),拷贝构造函数

 转自

一. 哪些是拷贝构造函数

 

对此普通品种的对象的话,它们中间的复制是很简短的,比如:
int a=88;
int b=a; 

 

而类对象与普通对象差别,类对象内部结构一般较为复杂,存在种种成员变量。上边看四个类对象拷贝的简易例子。 

 

 1 #include <iostream>
 2 using namespace std;
 3 
 4 class CExample {
 5 private:
 6      int a;
 7 public:
 8       //构造函数
 9      CExample(int b)
10      { a = b;}
11 
12       //一般函数
13      void Show ()
14      {
15         cout<<a<<endl;
16       }
17 };
18 
19 int main()
20 {
21      CExample A(100);
22      CExample B = A; //注意这里的对象初始化要调用拷贝构造函数,而非赋值
23       B.Show ();
24      return 0;
25 }

 

运行程序,显示器输出100。

 

从以上代码的运行结果能够见到,系统为目的B分配了内部存款和储蓄器并成功了与对象A的复制进度。就类对象来说,一样等级次序的类对象是因此拷贝构造函数来达成全套复制进度的。

 

下边比如表达拷贝构造函数的办事历程:

 1 #include <iostream>
 2 using namespace std;
 3 
 4 class CExample {
 5 private:
 6     int a;
 7 public:
 8     //构造函数
 9     CExample(int b)
10     { a = b;}
11     
12     //拷贝构造函数
13     CExample(const CExample& C)
14     {
15         a = C.a;
16     }
17 
18     //一般函数
19     void Show ()
20     {
21         cout<<a<<endl;
22     }
23 };
24 
25 int main()
26 {
27     CExample A(100);
28     CExample B = A; // CExample B(A); 也是一样的
29      B.Show ();
30     return 0;
31 } 

 

CExample(const CExample& C)正是大家自定义的正片构造函数。可知,拷贝构造函数是一种极度的构造函数,函数的称号必得和类名称同样,它的独一的一个参数是本类型的一个援用变量,该参数是const类型,不可变的。举个例子:类X的正片构造函数的款型为X(X& x)。

 

 

二. 拷贝构造函数的调用机缘

当用叁个已开端化过了的自定义类类型对象去初步化另八个新组织的指标的时候,拷贝构造函数就能够被活动调用。也正是说,当类的对象必要拷贝时,拷贝构造函数将会被调用。以下景况都会调用拷贝构造函数:

 在C++中,上边三种对象急需调用拷贝构造函数!


二个目的以值传递的措施传入函数体 :

 1 class CExample 
 2 {
 3 private:
 4  int a;
 5 
 6 public:
 7  //构造函数
 8  CExample(int b)
 9  { 
10   a = b;
11   cout<<"creat: "<<a<<endl;
12  }
13 
14  //拷贝构造
15  CExample(const CExample& C)
16  {
17   a = C.a;
18   cout<<"copy"<<endl;
19  }
20  
21  //析构函数
22  ~CExample()
23  {
24   cout<< "delete: "<<a<<endl;
25  }
26 
27      void Show ()
28  {
29          cout<<a<<endl;
30      }
31 };
32 
33 //全局函数,传入的是对象
34 void g_Fun(CExample C)
35 {
36  cout<<"test"<<endl;
37 }
38 
39 int main()
40 {
41  CExample test(1);
42  //传入对象
43  g_Fun(test);
44 
45  return 0;
46 }

 

 

运转结果:

1 creat: 1
2 copy
3 test
4 delete: 1
5 delete: 1
6 
7 Process returned 0 (0x0)   execution time : 0.498 s
8 Press any key to continue.

 

 

调用g_Fun()时,会发生以下多少个重要步骤:
(1).test对象传入形参时,会先会爆发一个不时变量,就叫 C 吧。
(2).然后调用拷贝构造函数把test的值给C。 整个那七个步骤有一点点像:CExample C(test);
(3).等g_Fun()施行完后, 析构掉 C 对象。


一个对象以值传递的点子从函数重返:

 

 1 class CExample 
 2 {
 3 private:
 4  int a;
 5 
 6 public:
 7  //构造函数
 8  CExample(int b)
 9  { 
10   a = b;
11  }
12 
13  //拷贝构造
14  CExample(const CExample& C)
15  {
16   a = C.a;
17   cout<<"copy"<<endl;
18  }
19 
20      void Show ()
21      {
22          cout<<a<<endl;
23      }
24 };
25 
26 //全局函数
27 CExample g_Fun()
28 {
29  CExample temp(0);
30  return temp;
31 }
32 
33 int main()
34 {
35  g_Fun();
36  return 0;
37 }

 

当g_Fun()函数实施到return时,会发出以下多少个至关心保护要步骤:
(1). 先会产生两个近来变量,就叫XXXX吧。
(2). 然后调用拷贝构造函数把temp的值给XXXX。整个那三个步骤有点像:CExample XXXX(temp);
(3). 在函数施行到结尾先析构temp局地变量。
(4). 等g_Fun()实践完后再析构掉XXXX对象。

 
二个指标急需经过其余四个目的开展初步化:

 

1 CExample A(100);
2 CExample B = A; 
3 // CExample B(A); 

 

后两句都会调用拷贝构造函数。

 

 

 

三. 浅拷贝和深拷贝

 

1. 默许拷贝构造函数

    比比较多时候在大家都不明白拷贝构造函数的场所下,传递对象给函数参数或然函数再次来到对象都能很好的开展,这是因为编写翻译器会给大家自行发出三个拷贝构造函数,那正是“私下认可拷贝构造函数”,那几个构造函数很简短,仅仅使用“老对象”的数量成员的值对“新对象”的数目成员相继举行赋值,它一般装有以下格局:

1 Rect::Rect(const Rect& r)
2 {
3     width = r.width;
4     height = r.height;
5 }

    当然,以上代码不用我们编辑,编写翻译器会为大家自动生成。可是一旦感觉那样就能够减轻对象的复制难题,那就错了,让大家来虚拟以下一段代码:

 1 class Rect
 2 {
 3 public:
 4     Rect()      // 构造函数,计数器加1
 5     {
 6         count++;
 7     }
 8     ~Rect()     // 析构函数,计数器减1
 9     {
10         count--;
11     }
12     static int getCount()       // 返回计数器的值
13     {
14         return count;
15     }
16 private:
17     int width;
18     int height;
19     static int count;       // 一静态成员做为计数器
20 };
21 
22 int Rect::count = 0;        // 初始化计数器
23 
24 int main()
25 {
26     Rect rect1;
27     cout<<"The count of Rect: "<<Rect::getCount()<<endl;
28 
29     Rect rect2(rect1);   // 使用rect1复制rect2,此时应该有两个对象
30      cout<<"The count of Rect: "<<Rect::getCount()<<endl;
31 
32     return 0;
33 }

这段代码对前方的类,参加了二个静态成员,目标是张开计数。在主函数中,首先创设对象rect1,输出此时的对象个数,然后利用rect1复制出对象rect2,再出口此时的靶子个数,依照驾驭,此时应有有八个对象存在,但实际上程序运营时,输出的都以1,反应出独有1个指标。其余,在销毁对象时,由于会调用销毁多少个目的,类的析构函数会调用四次,此时的计数器将产生负数。

简言之,正是拷贝构造函数未有拍卖静态数据成员。

并发那些难题最根本就在于在复制对象时,计数器未有递增,大家再一次编写拷贝构造函数,如下:

 

 1 class Rect
 2 {
 3 public:
 4     Rect()      // 构造函数,计数器加1
 5     {
 6         count++;
 7     }
 8     Rect(const Rect& r)   // 拷贝构造函数
 9     {
10         width = r.width;
11         height = r.height;
12         count++;          // 计数器加1
13     }
14     ~Rect()     // 析构函数,计数器减1
15     {
16         count--;
17     }
18     static int getCount()   // 返回计数器的值
19     {
20         return count;
21     }
22 private:
23     int width;
24     int height;
25     static int count;       // 一静态成员做为计数器
26 };

 

2. 浅拷贝

    所谓浅拷贝,指的是在指标复制时,只对目标中的数据成员开展简短的赋值,暗许拷贝构造函数实行的也是浅拷贝。多数情状下“浅拷贝”已经能很好地干活了,可是要是指标存在了动态成员,那么浅拷贝就能出标题了,让大家着想如下一段代码:

 1 class Rect
 2 {
 3 public:
 4     Rect()      // 构造函数,p指向堆中分配的一空间
 5     {
 6         p = new int(100);
 7     }
 8     ~Rect()     // 析构函数,释放动态分配的空间
 9     {
10         if(p != NULL)
11         {
12             delete p;
13         }
14     }
15 private:
16     int width;
17     int height;
18     int *p;     // 一指针成员
19 };
20 
21 int main()
22 {
23     Rect rect1;
24     Rect rect2(rect1);   // 复制对象
25     return 0;
26 }

 

在运作定义rect1对象后,由于在构造函数中有贰个动态分配的讲话,因而进行后的内部存款和储蓄器景况大概如下:

 图片 1

 

    在选用rect1复制rect2时,由于举行的是浅拷贝,只是将成员的值实行赋值,那时 rect1.p= rect2.p,也即那多个指针指向了堆里的同一个上空,如下图所示:

图片 2

 

道理当然是那样的,那不是大家所期待的结果,在销毁对象时,多个指标的析构函数将对同贰个内部存款和储蓄器空间释放两遍,那就是八花九裂出现的由来。我们必要的不是多少个p有同一的值,而是多个p指向的空中有相同的值,消除办法正是应用“深拷贝”。

 

 

3. 深拷贝

  在“深拷贝”的状态下,对于目的中动态成员,就无法只是简单地赋值了,而应当重新动态分配空间,如上边包车型地铁例证就应有遵从如下的艺术进行管理:

 1 class Rect
 2 {
 3 public:
 4     Rect()      // 构造函数,p指向堆中分配的一空间
 5     {
 6         p = new int(100);
 7     }
 8     Rect(const Rect& r)
 9     {
10         width = r.width;
11         height = r.height;
12         p = new int;    // 为新对象重新动态分配空间
13         *p = *(r.p);
14     }
15     ~Rect()     // 析构函数,释放动态分配的空间
16     {
17         if(p != NULL)
18         {
19             delete p;
20         }
21     }
22 private:
23     int width;
24     int height;
25     int *p;     // 一指针成员
26 };

那时,在成就目的的复制后,内部存储器的二个大意景况如下:

 

图片 3

 

那会儿rect1的p和rect2的p各自指向一段内部存款和储蓄器空间,但它们对准的长空具有一样的内容,那正是所谓的“深拷贝”。

 

 

转自 一. 什么是拷贝构造函数 对于一般类型...

一. 什么是拷贝构造函数

 

对于常见品种的对象的话,它们之间的复制是很简短的,举个例子:
int a=88;
int b=a; 

 

而类对象与一般对象分裂,类对象内部结构一般比较复杂,存在各个成员变量。下边看叁个类对象拷贝的简易例子。 

 

 1 #include <iostream>
 2 using namespace std;
 3 
 4 class CExample {
 5 private:
 6      int a;
 7 public:
 8       //构造函数
 9      CExample(int b)
10      { a = b;}
11 
12       //一般函数
13      void Show ()
14      {
15         cout<<a<<endl;
16       }
17 };
18 
19 int main()
20 {
21      CExample A(100);
22      CExample B = A; //注意这里的对象初始化要调用拷贝构造函数,而非赋值
23       B.Show ();
24      return 0;
25 }

 

运营程序,显示屏输出100。

 

从以上代码的运维结果能够见见,系统为指标B分配了内部存款和储蓄器并形成了与对象A的复制进度。就类对象来说,同样档次的类对象是通过拷贝构造函数来变成全套复制过程的。

 

上边譬喻表明拷贝构造函数的专门的学问进度:

 1 #include <iostream>
 2 using namespace std;
 3 
 4 class CExample {
 5 private:
 6     int a;
 7 public:
 8     //构造函数
 9     CExample(int b)
10     { a = b;}
11     
12     //拷贝构造函数
13     CExample(const CExample& C)
14     {
15         a = C.a;
16     }
17 
18     //一般函数
19     void Show ()
20     {
21         cout<<a<<endl;
22     }
23 };
24 
25 int main()
26 {
27     CExample A(100);
28     CExample B = A; // CExample B(A); 也是一样的
29      B.Show ();
30     return 0;
31 } 

 

CExample(const CExample& C)正是我们自定义的正片构造函数。可知,拷贝构造函数是一种特别的构造函数,函数的名称必需和类名称一样,它的举世无双的一个参数是本类型的四个援用变量,该参数是const类型,不可变的。举例说:类X的正片构造函数的款型为X(X& x)。

 

 

二. 拷贝构造函数的调用机会

当用贰个已开首化过了的自定义类类型对象去开头化另五个新结构的指标的时候,拷贝构造函数就能够被活动调用。也正是说,当类的靶子供给拷贝时,拷贝构造函数将会被调用。以下景况都会调用拷贝构造函数:

 在C++中,上边二种对象急需调用拷贝构造函数!


二个目的以值传递的不二法门传入函数体 :

 1 class CExample 
 2 {
 3 private:
 4  int a;
 5 
 6 public:
 7  //构造函数
 8  CExample(int b)
 9  { 
10   a = b;
11   cout<<"creat: "<<a<<endl;
12  }
13 
14  //拷贝构造
15  CExample(const CExample& C)
16  {
17   a = C.a;
18   cout<<"copy"<<endl;
19  }
20  
21  //析构函数
22  ~CExample()
23  {
24   cout<< "delete: "<<a<<endl;
25  }
26 
27      void Show ()
28  {
29          cout<<a<<endl;
30      }
31 };
32 
33 //全局函数,传入的是对象
34 void g_Fun(CExample C)
35 {
36  cout<<"test"<<endl;
37 }
38 
39 int main()
40 {
41  CExample test(1);
42  //传入对象
43  g_Fun(test);
44 
45  return 0;
46 }

 

 

运营结果:

1 creat: 1
2 copy
3 test
4 delete: 1
5 delete: 1
6 
7 Process returned 0 (0x0)   execution time : 0.498 s
8 Press any key to continue.

 

 

调用g_Fun()时,会产生以下多少个主要步骤:
(1).test对象传入形参时,会先会产生三个不经常变量,就叫 C 吧。
(2).然后调用拷贝构造函数把test的值给C。 整个那四个步骤有一点点像:CExample C(test);
(3).等g_Fun()施行完后, 析构掉 C 对象。


叁个对象以值传递的诀要从函数再次来到:

 

 1 class CExample 
 2 {
 3 private:
 4  int a;
 5 
 6 public:
 7  //构造函数
 8  CExample(int b)
 9  { 
10   a = b;
11  }
12 
13  //拷贝构造
14  CExample(const CExample& C)
15  {
16   a = C.a;
17   cout<<"copy"<<endl;
18  }
19 
20      void Show ()
21      {
22          cout<<a<<endl;
23      }
24 };
25 
26 //全局函数
27 CExample g_Fun()
28 {
29  CExample temp(0);
30  return temp;
31 }
32 
33 int main()
34 {
35  g_Fun();
36  return 0;
37 }

 

当g_Fun()函数试行到return时,会发出以下多少个至关心重视要步骤:
(1). 先会发生多个前段时间变量,就叫XXXX吧。
(2). 然后调用拷贝构造函数把temp的值给XXXX。整个那五个步骤有一点点像:CExample XXXX(temp);
(3). 在函数实践到结尾先析构temp局地变量。
(4). 等g_Fun()实施完后再析构掉XXXX对象。

 
三个目的急需经过其它二个目的开展初步化:

 

1 CExample A(100);
2 CExample B = A; 
3 // CExample B(A); 

 

后两句都会调用拷贝构造函数。

 

 

 

三. 浅拷贝和深拷贝

 

1. 私下认可拷贝构造函数

    非常多时候在我们都不清楚拷贝构造函数的景况下,传递对象给函数参数或然函数再次来到对象都能很好的开展,那是因为编写翻译器会给我们机关发出二个拷贝构造函数,那便是“默许拷贝构造函数”,那么些构造函数很轻便,仅仅使用“老对象”的多少成员的值对“新指标”的多寡成员相继举行赋值,它一般装有以下格局:

1 Rect::Rect(const Rect& r)
2 {
3     width = r.width;
4     height = r.height;
5 }

    当然,以上代码不用大家编辑,编写翻译器会为咱们自动生成。但是只要以为这么就足以化解对象的复制难点,那就错了,让我们来思考以下一段代码:

 

 1 class Rect
 2 {
 3 public:
 4     Rect()      // 构造函数,计数器加1
 5     {
 6         count++;
 7     }
 8     ~Rect()     // 析构函数,计数器减1
 9     {
10         count--;
11     }
12     static int getCount()       // 返回计数器的值
13     {
14         return count;
15     }
16 private:
17     int width;
18     int height;
19     static int count;       // 一静态成员做为计数器
20 };
21 
22 int Rect::count = 0;        // 初始化计数器
23 
24 int main()
25 {
26     Rect rect1;
27     cout<<"The count of Rect: "<<Rect::getCount()<<endl;
28 
29     Rect rect2(rect1);   // 使用rect1复制rect2,此时应该有两个对象
30      cout<<"The count of Rect: "<<Rect::getCount()<<endl;
31 
32     return 0;
33 }

这段代码对前方的类,加入了贰个静态成员,目标是扩充计数。在主函数中,首先创设对象rect1,输出此时的目的个数,然后利用rect1复制出对象rect2,再出口此时的靶子个数,遵照驾驭,此时应当有五个目的存在,但实质上程序运转时,输出的都是1,反应出只有1个指标。其余,在销毁对象时,由于会调用销毁三个对象,类的析构函数会调用五遍,此时的计数器将变为负数。

简短,正是拷贝构造函数未有拍卖静态数据成员。

并发这么些主题素材最根本就在于在复制对象时,计数器未有递增,大家重新编排拷贝构造函数,如下:

 

 1 class Rect
 2 {
 3 public:
 4     Rect()      // 构造函数,计数器加1
 5     {
 6         count++;
 7     }
 8     Rect(const Rect& r)   // 拷贝构造函数
 9     {
10         width = r.width;
11         height = r.height;
12         count++;          // 计数器加1
13     }
14     ~Rect()     // 析构函数,计数器减1
15     {
16         count--;
17     }
18     static int getCount()   // 返回计数器的值
19     {
20         return count;
21     }
22 private:
23     int width;
24     int height;
25     static int count;       // 一静态成员做为计数器
26 };

 

 

2. 浅拷贝

 

    所谓浅拷贝,指的是在目的复制时,只对指标中的数据成员进行简易的赋值,默许拷贝构造函数推行的也是浅拷贝。多数意况下“浅拷贝”已经能很好地干活了,但是假使指标存在了动态成员,那么浅拷贝就能够出难点了,让我们着想如下一段代码:

 1 class Rect
 2 {
 3 public:
 4     Rect()      // 构造函数,p指向堆中分配的一空间
 5     {
 6         p = new int(100);
 7     }
 8     ~Rect()     // 析构函数,释放动态分配的空间
 9     {
10         if(p != NULL)
11         {
12             delete p;
13         }
14     }
15 private:
16     int width;
17     int height;
18     int *p;     // 一指针成员
19 };
20 
21 int main()
22 {
23     Rect rect1;
24     Rect rect2(rect1);   // 复制对象
25     return 0;
26 }

 

在运作定义rect1对象后,由于在构造函数中有多少个动态分配的言辞,因而进行后的内部存款和储蓄器景况大约如下:

 图片 4

 

    在应用rect1复制rect2时,由于实施的是浅拷贝,只是将成员的值进行赋值,那时 rect1.p= rect2.p,也即那四个指针指向了堆里的同多少个空中,如下图所示:

图片 5

 

自然,那不是我们所期望的结果,在销毁对象时,三个指标的析构函数将对同三个内部存款和储蓄器空间释放四遍,那正是错误出现的缘故。我们需求的不是七个p有一致的值,而是三个p指向的上空有同等的值,化解办法就是使用“深拷贝”。

 

 

 

3. 深拷贝

 

  在“深拷贝”的景色下,对于目的中动态成员,就无法单纯轻便地赋值了,而相应再度动态分配空间,如上边包车型客车事例就应该依据如下的法子开展管理:

 1 class Rect
 2 {
 3 public:
 4     Rect()      // 构造函数,p指向堆中分配的一空间
 5     {
 6         p = new int(100);
 7     }
 8     Rect(const Rect& r)
 9     {
10         width = r.width;
11         height = r.height;
12         p = new int;    // 为新对象重新动态分配空间
13         *p = *(r.p);
14     }
15     ~Rect()     // 析构函数,释放动态分配的空间
16     {
17         if(p != NULL)
18         {
19             delete p;
20         }
21     }
22 private:
23     int width;
24     int height;
25     int *p;     // 一指针成员
26 };

那儿,在实现指标的复制后,内存的一个大概情状如下:

 

图片 6

 

此刻rect1的p和rect2的p各自指向一段内部存款和储蓄器空间,但它们对准的空中具备同等的开始和结果,那就是所谓的“深拷贝”。

 

 

编辑:计算机网络 本文来源:深拷贝与浅拷贝

关键词: