C++ 浅拷贝与深拷贝探究

C++浅拷贝与深拷贝探究

---

浅拷贝与深拷贝的概念是在类的复制/拷贝构造函数中出现的。

拷贝构造函数使用场景

• 对象作为参数，以值传递方式传入函数(要调用拷贝构造函数将实参拷贝给函数栈中的形参)
• 对象作为返回值，以值方式返回（要调用拷贝构造函数，将要传出的对象拷贝给一个外作用域的临时对象）
• 用一个对象去初始化另外一个对象

浅拷贝：直接使用 “=” 赋值，拷贝给定对象属性。（如果是一般类型，那么就相当于赋值运算符。如果有指针，赋值后就相当于拷贝双方指向同一个地址）

private:

xxx *pStr;

......

pStr = m.pStr;//拷贝的是地址

深拷贝：在赋值之前，先给指针申请一段内存，而后拷贝给定对象属性值。（即：先申请内存，再赋值）

pStr = new xxx[xxx];//先申请内存

对pStr赋值//再拷贝值

实例说明

浅拷贝

 #pragma once
 class Demo
 {
 private:
     int m_icount;
     int *pStr;
 public:
     Demo(int icount);//构造函数
     Demo(const Demo &d);//拷贝构造函数(浅拷贝)
     ~Demo();//析构函数
     void setValue(int icount);
     void printValue();
     void printAddr();
 };

Demo.h

 #include "Demo.h"
 #include <iostream>
 using namespace std;

 Demo::Demo(int icount)
 {
     m_icount = icount;
     pStr = new int[m_icount];
     for (int i = ; i < m_icount; i++)
     {
         pStr[i] = i;
     }
     cout << "\nDemo(int value)构造函数被调用！" << endl;
 }

 Demo::Demo(const Demo &d)
 {
     m_icount = d.m_icount;
     //浅拷贝
     pStr = d.pStr;//浅拷贝，赋地址
     cout << "Demo(const Demo &d)浅拷贝构造函数被调用！" << endl;

     //深拷贝
     /*pStr = new int[m_icount];
     for (int i = 0; i < m_icount; i++)
     {
         pStr[i] = d.pStr[i];
     }
     cout << "\nDemo(const Demo &d)深拷贝构造函数被调用！" << endl;*/
 }

 Demo::~Demo()
 {
     delete[]pStr;
     pStr = NULL;
     cout << "\n~Demo()析构函数被调用！" << endl;
 }

 void Demo::setValue(int icount)
 {
     m_icount = icount;
     cout << "\nsetValue(int icount)函数被调用！" << endl;
 }

 void Demo::printValue()
 {
     for (int i = ; i < m_icount; i++)
     {
         cout << pStr[i] << "  ";
     }
     cout << "\nDemo::printValue()函数被调用！" << endl;
 }

 void Demo::printAddr()
 {
     cout << pStr << endl;
 }

 int main()
 {
     Demo d1();
     cout << "\nd1 : ";
     d1.printValue();

     d1.setValue();
     cout << "\nd1 : ";
     d1.printValue();

     Demo d2(d1);
     cout << "\nd2 :";
     d2.printValue();

     cout << "\nd1 addr : ";
     d1.printAddr();
     cout << "\nd2 addr : ";
     d2.printAddr();

     system("pause");
 }

Demo.cpp

//代码中的拷贝构造函数形参 const Demo &d

//const: 禁止在传参过程中改变参数对象

//&d：引用传递，参数如果不是引用传递，那么在将实参拷贝给形参时就要调用拷贝构造函数，而函数自身就是拷贝构造函数，就会不断调用自己，陷入递归，无法自拔。->拷贝构造函数必须使用引用传递！！！

结果

那么，对于两者中任意一个对象进行操作就势必会改变另外一个，这是我们一般不希望看到的。这时候，我们就需要深拷贝。为即将产生的新对象重新申请存储空间。

深拷贝

 #include "Demo.h"
 #include <iostream>
 using namespace std;

 Demo::Demo(int icount)
 {
     m_icount = icount;
     pStr = new int[m_icount];
     for (int i = ; i < m_icount; i++)
     {
         pStr[i] = i;
     }
     cout << "\nDemo(int value)构造函数被调用！" << endl;
 }

 Demo::Demo(const Demo &d)
 {
     m_icount = d.m_icount;
     //浅拷贝
     /*pStr = d.pStr;//浅拷贝，赋地址
     cout << "Demo(const Demo &d)浅拷贝构造函数被调用！" << endl;*/

     //深拷贝
     pStr = new int[m_icount];
     for (int i = ; i < m_icount; i++)
     {
         pStr[i] = d.pStr[i];
     }
     cout << "\nDemo(const Demo &d)深拷贝构造函数被调用！" << endl;
 }

 Demo::~Demo()
 {
     delete[]pStr;
     pStr = NULL;
     cout << "\n~Demo()析构函数被调用！" << endl;
 }

 void Demo::setValue(int icount)
 {
     m_icount = icount;
     cout << "\nsetValue(int icount)函数被调用！" << endl;
 }

 void Demo::printValue()
 {
     for (int i = ; i < m_icount; i++)
     {
         cout << pStr[i] << "  ";
     }
     cout << "\nDemo::printValue()函数被调用！" << endl;
 }

 void Demo::printAddr()
 {
     cout << pStr << endl;
 }

 int main()
 {
     Demo d1();
     cout << "\nd1 : ";
     d1.printValue();

     d1.setValue();
     cout << "\nd1 : ";
     d1.printValue();

     Demo d2(d1);
     cout << "\nd2 :";
     d2.printValue();

     cout << "\nd1 addr : ";
     d1.printAddr();
     cout << "\nd2 addr : ";
     d2.printAddr();

     system("pause");
 }

Demo.cpp

结果

简言之，浅拷贝就是把别人的地址拿过来作为自己的，双方共同维护一个对象，“绑在一块，一损俱损”；而深拷贝则是赋值之前为新对象申请了额外的空间，所以独立于被拷贝对象，“咱没关系，爱咋咋地”！

拷贝构造函数使用原则

• 含有指针类型的成员或者含有动态内存空间的对象，必须提供自定义的拷贝构造函数。
• 在提供拷贝构造函数的同时，也要考虑实现自定义的赋值运算符。

怎样区别

赋值运算还是拷贝函数？有无新对象产生

深拷贝还是浅拷贝？有无指针成员和动态内存空间