C++深拷贝，浅拷贝

最新推荐文章于 2023-08-06 17:00:35 发布
最新推荐文章于 2023-08-06 17:00:35 发布
阅读量311 收藏
点赞数
分类专栏： c/c++

原文地址：http://www.cnblogs.com/BlueTzar/articles/1223313.html

对于普通类型的对象来说，它们之间的复制是很简单的，例如：
int a=88;
int b=a; 
而类对象与普通对象不同，类对象内部结构一般较为复杂，存在各种成员变量。下面看一个类对象拷贝的简单例子。 

#include <iostream>
using namespace std;

class CExample {
private:
    　int a;
public:
    　CExample(int b)
    　{ a=b;}
    　void Show ()
    　{
        cout<<a<<endl;
    }
};

int main()
{
    　CExample A(100);
    　CExample B=A;
    　B.Show ();
    　return 0;
} 

运行程序，屏幕输出100。从以上代码的运行结果可以看出，系统为对象B分配了内存并完成了与对象A的复制过程。就类对象而言，相同类型的类对象是通过拷贝构造函数来完成整个复制过程的。下面举例说明拷贝构造函数的工作过程。

#include <iostream>
using namespace std;

class CExample {
private:
    int a;
public:
    CExample(int b)
    { a=b;}
    
    CExample(const CExample& C)
    {
        a=C.a;
    }
    void Show ()
    {
        cout<<a<<endl;
    }
};

int main()
{
    CExample A(100);
    CExample B=A;
    B.Show ();
    return 0;
} 

CExample(const CExample& C)就是我们自定义的拷贝构造函数。可见，拷贝构造函数是一种特殊的构造函数，函数的名称必须和类名称一致，它的唯一的一个参数是本类型的一个引用变量，该参数是const类型，不可变的。例如：类X的拷贝构造函数的形式为X(X& x)。

当用一个已初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候，拷贝构造函数就会被自动调用。也就是说，当类的对象需要拷贝时，拷贝构造函数将会被调用。以下情况都会调用拷贝构造函数：
一个对象以值传递的方式传入函数体 
一个对象以值传递的方式从函数返回 
一个对象需要通过另外一个对象进行初始化。

如果在类中没有显式地声明一个拷贝构造函数，那么，编译器将会自动生成一个默认的拷贝构造函数，该构造函数完成对象之间的位拷贝。位拷贝又称浅拷贝，后面将进行说明。

自定义拷贝构造函数是一种良好的编程风格，它可以阻止编译器形成默认的拷贝构造函数，提高源码效率。

浅拷贝和深拷贝

　　在某些状况下，类内成员变量需要动态开辟堆内存，如果实行位拷贝，也就是把对象里的值完全复制给另一个对象，如A=B。这时，如果B中有一个成员变量指针已经申请了内存，那A中的那个成员变量也指向同一块内存。这就出现了问题：当B把内存释放了（如：析构），这时A内的指针就是野指针了，出现运行错误。

　　深拷贝和浅拷贝可以简单理解为：如果一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝，反之，没有重新分配资源，就是浅拷贝。下面举个深拷贝的例子。

#include <iostream>
using namespace std;
class CA
{
　public:
　　CA(int b,char* cstr)
　　{
　　　a=b;
　　　str=new char[b];
　　　strcpy(str,cstr);
　　}
　　CA(const CA& C)
　　{
　　　a=C.a;
　　　str=new char[a]; //深拷贝
　　　if(str!=0)
　　　　strcpy(str,C.str);
　　}
　　void Show()
　　{
　　　cout<<str<<endl;
　　}
　　~CA()
　　{
　　　delete str;
　　}
　private:
　　int a;
　　char *str;
};

int main()
{
　CA A(10,"Hello!");
　CA B=A;
　B.Show();
　return 0;
} 

深拷贝和浅拷贝的定义可以简单理解成：如果一个类拥有资源(堆，或者是其它系统资源)，当这个类的对象发生复制过程的时候，这个过程就可以叫做深拷贝，反之对象存在资源，但复制过程并未复制资源的情况视为浅拷贝。

浅拷贝资源后在释放资源的时候会产生资源归属不清的情况导致程序运行出错。

        Test(Test &c_t)是自定义的拷贝构造函数，拷贝构造函数的名称必须与类名称一致，函数的形式参数是本类型的一个引用变量,且必须是引用。

当用一个已经初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候，拷贝构造函数就会被自动调用，如果你没有自定义拷贝构造函数的时候，系统将会提供给一个默认的拷贝构造函数来完成这个过程，上面代码的复制核心语句就是通过Test(Test &c_t)拷贝构造函数内的p1=c_t.p1;语句完成的。


其实上面这篇文章对于拷贝构造函数与重载的复制运算符有些混淆，文中也说过只有三种情况下是调用拷贝构造函数的，下面的文章对于两者调用的时机有更清楚的说明

原文地址：http://www.jellythink.com/archives/378

前言

这篇文章将对C++中复制构造函数和重载赋值操作符进行总结，包括以下内容：

  1. 复制构造函数和重载赋值操作符的定义；
  2. 复制构造函数和重载赋值操作符的调用时机；
  3. 复制构造函数和重载赋值操作符的实现要点；
  4. 复制构造函数的一些细节。
复制构造函数和重载赋值操作符的定义

我们都知道，在C++中建立一个类，这个类中肯定会包括构造函数、析构函数、复制构造函数和重载赋值操作；即使在你没有明确定义的情况下，编译器也会给你生成这样的四个函数。例如以下类：

class CTest
{
public:
     CTest();
     ~CTest();

     CTest(const CTest &);
     CTest& operator=(const CTest &);
};

对于构造函数和析构函数不是今天总结的重点，今天的重点是复制构造函数和重载赋值操作。类的复制构造函数原型如下：

class_name(const class_name &src);

一般来说，如果我们没有编写复制构造函数，那么编译器会自动地替每一个类创建一个复制构造函数（也叫隐式复制构造函数）；相反的，如果我们编写了一个复制构造函数（显式的复制构造函数），那么编译器就不会创建它。

类的重载赋值操作符的原型如下：

class_name& operator=(const class_name &);

重载赋值操作符是一个特别的赋值运算符，通常是用来把已存在的对象指定给其它相同类型的对象。它是一个特别的成员函数，如果我们没有定义这个成员函数，那么编译器会自动地产生这个成员函数。编译器产生的代码是以单一成员进行对象复制的动作。

总结了复制构造函数和重载赋值操作符的定义，只是让我们了解了它们，而没有真正的深入它们。接下来，再仔细的总结一下它们的调用时机。关于它们的调用时机，我一直都没有真正的明白过，所以这里一定要好好的总结明白了。

复制构造函数和重载赋值操作符的调用时机

对复制构造函数和重载赋值操作符的调用总是发生在不经意间，它们不是经过我们显式的去调用就被执行了。对于这种隐式调用的地方一定要多注意了，这也一般是有陷阱的地方。现在我就用实际的例子来进行验证；例子如下：

#include <iostream>
using namespace std;

class CTest
{
public:
     CTest(){}
     ~CTest(){}

     CTest(const CTest &test)
     {
          cout<<"copy constructor."<<endl;
     }

     void operator=(const CTest &test)
     {
          cout<<"operator="<<endl;
     }

     void Test(CTest test)
     {}

     CTest Test2()
     {
          CTest a;
          return a;
     }

     void Test3(CTest &test)
     {}

     CTest &Test4()
     {
          CTest *pA = new CTest;
          return *pA;
     }
};

int main()
{
     CTest obj;

     CTest obj1(obj); // 调用复制构造函数

     obj1 = obj; // 调用重载赋值操作符

     /* 传参的过程中，要调用一次复制构造函数
     * obj1入栈时会调用复制构造函数创建一个临时对象，与函数内的局部变量具有相同的作用域
     */
     obj.Test(obj1);

     /* 函数返回值时，调用复制构造函数；将返回值赋值给obj2时，调用重载赋值操作符
     * 函数返回值时，也会构造一个临时对象；调用复制构造函数将返回值复制到临时对象上
     */
     CTest obj2；
     obj2 = obj.Test2();

     obj2.Test3(obj); // 参数是引用，没有调用复制构造函数

     CTest obj3;
     obj2.Test4(); // 返回值是引用，没有调用复制构造函数

     return 0;
}

在代码中都加入了注释，这里就不再做详细的说明了。再次总结一下，如果对象在声明的同时将另一个已存在的对象赋给它，就会调用复制构造函数；如果对象已经存在了，然后再将另一个已存在的对象赋给它，调用的就是重载赋值运算符了。这条规则很适用，希望大家能记住。

复制构造函数和重载赋值操作符的实现要点

在一般的情况下，编译器给我们生成的默认的复制构造函数和重载赋值操作符就已经够用了；但是在一些特别的时候，需要我们手动去实现自己的复制构造函数。

我们都知道，默认的复制构造函数和赋值运算符进行的都是”shallow copy”，只是简单地复制字段，因此如果对象中含有动态分配的内存，就需要我们自己重写复制构造函数或者重载赋值运算符来实现”deep copy”，确保数据的完整性和安全性。这也就是大家常常说的深拷贝与浅拷贝的问题。下面我就提供一个比较简单的例子来说明一下：

#include <iostream>
using namespace std;

const int MAXSIZE = 260;

class CTest
{
public:
     CTest(wchar_t *pInitValue)
     {
          // Here, I malloc the memory
          pValue = new wchar_t[MAXSIZE];
          memset(pValue, 0, sizeof(wchar_t) * MAXSIZE);
          wcscpy_s(pValue, MAXSIZE, pInitValue);
     }

     ~CTest()
     {
          if (pValue)
          {
               delete[] pValue; //finalseabiscuit指出，谢谢。2014.7.24
               pValue = NULL;
          }
     }

     CTest(const CTest &test)
     {
          // Malloc the new memory for the pValue
          pValue = new wchar_t[MAXSIZE];
          memset(pValue, 0, sizeof(wchar_t) * MAXSIZE);
          wcscpy_s(pValue, MAXSIZE, test.pValue);
     }

     CTest& operator=(const CTest &test)
     {
          // This is very important, please remember
          if (this == &test)
          {
               return *this;
          }

          // Please delete the memory, this maybe cause the memory leak
          if (pValue)
          {
               delete[] pValue; // 方恒刚指出的问题。非常感谢 2014.3.15
          }

          // Malloc the new memory for the pValue
          pValue = new wchar_t[MAXSIZE];
          memset(pValue, 0, sizeof(wchar_t) * MAXSIZE);
          wcscpy_s(pValue, MAXSIZE, test.pValue);
          return *this;
     }

     void Print()
     {
          wcout<<pValue<<endl;
     }

private:
     wchar_t *pValue; // The pointer points the memory
};

int main()
{
     CTest obj(L"obj");
     obj.Print();

     CTest obj2(L"obj2");
     obj2.Print();
     obj2 = obj;
     obj2.Print();

     obj2 = obj2;
     obj2.Print();

     return 0;
}

特别是在实现重载赋值构造函数时需要多多的注意，在代码中我也添加了注释，大家可以认真的阅读一下代码，然后就懂了，如果不懂的就可以留言问我；当然了，如果我哪里理解错了，也希望大家能给我提出，我们共同进步。

复制构造函数的一些细节
  1. 以下哪些是复制构造函数 
    X::X(const X&);   
X::X(X);   
X::X(X&, int a=1);   
X::X(X&, int a=1, int b=2);
    这些细节问题在这里也说一说，我也是从别人的博客里看到的，这里自己也总结一下。对于一个类X, 如果一个构造函数的第一个参数是下列之一: 
    a) X&
b) const X&
c) volatile X&
d) const volatile X&
    且没有其他参数或其他参数都有默认值，那么这个函数是拷贝构造函数。 
    X::X(const X&);  //是拷贝构造函数   
X::X(X&, int=1); //是拷贝构造函数  
X::X(X&, int a=1, int b=2); //当然也是拷贝构造函数
  2. 类中可以存在超过一个拷贝构造函数 
    class X 
{ 
public:       
  X(const X&);      // const 的拷贝构造
  X(X&);            // 非const的拷贝构造
};
    注意，如果一个类中只存在一个参数为 X& 的拷贝构造函数，那么就不能使用const X或volatile X的对象实行拷贝初始化。如果一个类中没有定义拷贝构造函数,那么编译器会自动产生一个默认的拷贝构造函数。这个默认的参数可能为 X::X(const X&)或 X::X(X&),由编译器根据上下文决定选择哪一个。在我的Visual Studio 2012中，当定义了多个复制构造函数以后，编译器就会有warning，但是程序还能正确运行。
总结

这篇文章对复制构造函数和重载赋值操作符进行了一些总结，重点是在复制构造函数与重载赋值操作符的调用时机上；对于大家喜欢总结的深拷贝与浅拷贝问题，我没有用过多的文字进行说明，我认为上面的代码就足以说明问题了。最后自己纠结已久的问题也就这样总结了，自己也彻底的明白了。

2014年2月21日 于大连，东软。


yunwu753
关注
专栏目录
详解常见面试题---深拷贝和浅拷贝(C++)
KOOKNUT的博客
06-30 2776
C++类对象的赋值操作分为深拷贝和浅拷贝两种，我们所说的的浅拷贝就是赋值操作，这种拷贝比较常见，比如： class A { public: A(); ~A(); public: int i; }; A::A() { i = 5; } A::~A() { } void main() { A a1;//执行默认构造函数 初始化a1.i = 7 A a2 = a1;//发生赋值操作 此刻a2.i = 5 a2.i = 7;//只修改a2中的成员，对a1中的不造成影响 return; }
刻苦铭心的WCHAR
caojq9902的专栏
12-11 405
       终于在经过一点时间的迷茫后，又开始走入正规，下班的时候，开始折腾起前面一直不敢拿起的symbina。       前面一大堆的感谢就不说了，特别当然是misuo兄。       今天调试文件类，本来昨天就写好了文件seek定位的函数，但是今天调试的时候，发现读取显示的时候，总是ccccccc，当时脑袋瓜笨，第一感觉就是读写不正确，于是乎单步进去，首先文件指针设置确实返回正确，
多字节字符集模式 CString转wchar* 字符串拷贝到粘贴板
|-青青子衿-| 的专栏
12-02 520
要解决的问题：在MFC对话框应用程序中，选择列表框中的某一项，并拷贝该项的字符创到粘贴板上。项目中字符集属性为:使用多字节字符集。
c++数据格式化输出/字符串复制/字符串比较
hanxiaoyong_的博客
06-02 693
sprintf_s比
如何拷贝一个wchar_t类型的字符串
weixin_33711641的博客
02-28 2992
Do this, wchar_t clone[260]; wcscpy(clone,szPath); Or, if you want to allocate memory yourself, wchar_t *clone = new wchar_t[wcslen(szPath)+1]; wcscpy(clone,szPath); //use it d...
C++拷贝wstring到wchar_t*中踩的坑
weixin_43891802的博客
08-06 962
使用wchar_t指针将wstring中的数据拿出来，发现释放的时候异常
C++ 深拷贝浅拷贝
lisaaaaaas0405的博客
05-21 335
一、概念 深拷贝：指的是拷贝一个对象时，不仅仅把对象的引用进行复制，还把该对象引用的值也一起拷贝。这样进行深拷贝后的拷贝对象就和源对象互相独立，其中任何一个对象的改动都不会对另外一个对象造成影响。 浅拷贝：指的是拷贝一个对象时，仅仅拷贝对象的引用进行拷贝，但是拷贝对象和源对象还是引用同一份实体。此时，其中一个对象的改变都会影响到另一个对象。 浅拷贝示例： #include<iost...
C++深拷贝浅拷贝
05-30
根据提供的标题、描述和部分无法识别的内容，我们将围绕“C++深拷贝与浅拷贝”的主题进行深入探讨。在C++编程语言中，深拷贝（Deep Copy）与浅拷贝（Shallow Copy）是对象复制时经常遇到的概念。它们在内存管理和...
c++深拷贝 浅拷贝
09-04
深拷贝和浅拷贝是在编程中常用的两个概念，用于描述对象或数据的复制方式。 浅拷贝是指创建一个新的对象或数据，并将原始对象或数据中的值复制到新对象或数据中。但是，如果原始对象或数据中包含其他对象的引用，浅...
c++ 深拷贝 浅拷贝
09-10
深拷贝（deep copy）和浅拷贝（shallow copy）是在编程中用于复制对象的两种不同方式。 浅拷贝是指创建一个新的对象，该对象中的属性值是原始对象的引用。换句话说，新对象中的属性和原始对象中的属性指向同一块...
C/C++ 浅拷贝和深拷贝的实例详解
01-01
C/C++ 浅拷贝和深拷贝的实例详解 深拷贝是指拷贝对象的具体内容，而内存地址是自主分配的，拷贝结束之后，两个对象虽然存的值是相同的，但是内存地址不一样，两个对象也互不影响，互不干涉。 浅拷贝就是对内存地址...
c++ 宽字符文件的拷贝
大尾巴毛的博客
03-27 1779
copy2.h #ifndef _COPY2_H_ #define _COPY2_H_ #include <iostream> #include <string> using namespace std; #define MAX_COPY_SIZE 4096 * 32 extern "C" { /* * file_copy: Îļþ¿½±´º¯Êý ...
wchar_t*转std::string详解
jfkidear的专栏
05-08 2740
wchar_t*转std::string详解  主要思路： 1、将wchar_t*的字符串转为char*字符串 2、然后直接用std::string的operator=做赋值操作   案例： //std::string的目标   std::string szDst;  //wText为wchar_t*的内容    wchar_t wText[20] =
深拷贝的三种方式
weixin_30240349的博客
06-03 1716
JSON方法 var obj2 =JSON.parse（JSON.stringify(obj1)）//深拷贝 递归(自己调用自己)方法 判断第一层属性的类型，多层拷贝对象的属性 var obj1 = { name: 'zs', age: 18, dog: { name: '金毛', age: 2 }, friends: ['ww', 'lil'] } var obj2 = {}; functio...
注册会计师会计第十五章 债务重组.doc
09-16
注册会计师会计第十五章 债务重组.doc
第0章 前言.doc
09-16
第0章 前言.doc
python链表实战制作学生管理系统（附带pyqt5的界面优化）
最新发布
09-16
python链表实战制作学生管理系统（附带pyqt5的界面优化）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值