C++深拷贝和浅拷贝

对象的拷贝:
普通类型的对象拷贝:
int nTest = 88;
int nTest1 = nTest;
int nTest2( nTest );

类对象的拷贝:
对于类对象的拷贝来说,相同类型的类对象使通过拷贝构造函数来实现的。对象的拷贝分为浅拷贝和深拷贝。

拷贝构造函数:
拷贝构造函数的名称必须和类名称一致,参数只有一个本类型的引用变量,该参数必须是const类型,用来确保该参数对象再拷贝构造函数内不能被改变。
拷贝构造函数格式如下:
CTest( const CTest& cValue){}

当对象需要被拷贝时,就会调用拷贝构造函数,如果这个类中没有生命拷贝构造函数的话,编辑器会生成一个默认拷贝构造函数,该默认拷贝构造函数完成对象之间的浅拷贝。

会调用拷贝构造函数的情况:
对象以值传递的方式传入函数体内。
对象以值传递的方式从函数中返回。
对象需要通过另外一个对象进行初始化。

浅拷贝和深拷贝:

浅拷贝:
直接为数据成员赋值即可。
如果类对象中有指针类型的成员,但是没有分配专门的内存,这时候浅拷贝是会带来问题的。
代码如下:
CShallowReplication.h文件中

#include <string.h>
//  浅拷贝

class CShallowRep{
public:
    CShallowRep(char* pValue, int nValue)
    {
        strcpy(pName, pValue);
        nAge = nValue;
    }

    void Show( )
    {
        cout << " Name is : " << pName << endl;
        cout << " Age is : " << nAge << endl;
    }

    void setName( char* pValue )
    {
        strcpy( pName, pValue);
        pName = pValue;
    }

    void setAge( int nValue )
    {
        nAge = nValue;
    }
public:
    char* pName;
    int nAge;
};

main.cpp文件中

#include <iostream>
#include <string>
using namespace std;

#include "ShallowReplication.h"
#include "DeepReplication.h"

void main()
{
    CShallowRep pShallowRep( "xiaoming", 30 );

    CShallowRep pShallowRep_2(pShallowRep);
    pShallowRep.Show();
    pShallowRep_2.Show();

    system("pause");
    return;
}

在启动程序的时候会有报错:
这里写图片描述

根据报错信息可以知道。程序试图将”xiaoming”拷贝到pName指向的位置,而pName指向的位置并不是经过系统分配来的,是随机的地址值,pName是一个野指针。这种行为是不被接受的。

深拷贝:
在构造函数中,为指针类型的成员,分配专门的内存。
在类的对象发生拷贝过程的时候,资源重新分配了,则这个过程就是深拷贝。

代码如下:
CDeepReplication.h文件中

#include <string.h>
//  深拷贝

class CDeepRep{
public:
    CDeepRep(char* pValue, int nValue)
    {
        pName = new char[strlen(pValue) + 1];   //  分配pName的内存
        strcpy(pName, pValue);
        nAge = nValue;
    }

    CDeepRep(const CDeepRep& rDeepRep)
    {
        nAge = rDeepRep.nAge;
        pName = new char[strlen(rDeepRep.pName) + 1];
        strcpy(pName, rDeepRep.pName);
    }

    ~CDeepRep()
    {
        delete[] pName;
    }

    void Show( )
    {
        cout << " Name is : " << pName << endl;
        cout << " Age is : " << nAge << endl;
    }

    void setName( char* pValue )
    {
        strcpy( pName, pValue);
        pName = pValue;
    }

    void setAge( int nValue )
    {
        nAge = nValue;
    }
public:
    char* pName;
    int nAge;
};

main.cpp文件中

#include <iostream>
#include <string>
using namespace std;

#include "ShallowReplication.h"
#include "DeepReplication.h"

void main()
{
    CDeepRep pDeepRep( "xiaoming", 30 );

    CDeepRep pDeepRep_2(pDeepRep);
    pDeepRep.Show();
    pDeepRep_2.setName( "xiaoqiang" );
    pDeepRep_2.Show();

    system("pause");
    return;
}

运行结果如下:
这里写图片描述

### C++深拷贝浅拷贝的概念及实现方式 #### 1. 概念区分 在 C++ 中,深拷贝浅拷贝主要涉及对象之间的赋值或复制行为。两者的核心差异在于是否对指针所指向的资源进行了真正的复制。 - **浅拷贝**仅复制指针本身而不复制其指向的实际数据,这意味着两个对象的指针最终会指向同一片内存区域[^1]。 - **深拷贝**不仅复制指针还对其指向的数据也进行完整的复制操作,从而使得源对象目标对象各自拥有独立的一份数据副本[^1]。 #### 2. 默认行为分析 C++ 编译器提供的默认拷贝构造函数执行的是浅拷贝逻辑。也就是说如果没有特别定义自己的版本,则当一个类含有动态分配成员变量(如 `new` 关键字创建的对象)时可能会引发双重删除或其他未定义行为问题[^3]。 #### 3. 实现方法对比 ##### (a) 浅拷贝示例 下面展示了不考虑深拷贝情况下的典型例子: ```cpp #include <iostream> using namespace std; class ShallowCopyExample { public: int* ptr; // 构造函数初始化指针 ShallowCopyExample(int value){ ptr = new int(value); } // 默认析构函数释放内存 ~ShallowCopyExample(){ delete ptr; } }; int main() { ShallowCopyExample obj1(10); ShallowCopyExample obj2 = obj1; // 使用默认拷贝构造 cout << "*obj1.ptr=" << *(obj1.ptr) << ", *obj2.ptr="<<*(obj2.ptr)<<endl; return 0; } ``` 上述代码中,`obj2=obj1` 的时候只是简单地将 `ptr` 地址赋予给了另一个实例,并没有真正克隆底层数值。这样就会造成潜在的风险:一旦任意一方销毁之后再访问另一方就可能导致非法读取错误。 ##### (b) 深拷贝示例 为了避免上述隐患,我们需要显式重写拷贝构造函数来进行深层次的数据迁移: ```cpp #include <iostream> using namespace std; class DeepCopyExample { private: int* dataPtr; public: // 构造函数 DeepCopyExample(int d):dataPtr(new int(d)){} // 自定义拷贝构造函数完成深拷贝 DeepCopyExample(const DeepCopyExample& source) : dataPtr(new int(*(source.dataPtr))) {} // 析构函数清理资源 ~DeepCopyExample(){delete dataPtr;} void setData(int newValue){*dataPtr=newValue;} int getData()const{return *dataPtr;} }; int main(){ DeepCopyExample originalObj(42); DeepCopyExample copiedObj(originalObj); cout<<"Original Data:"<<originalObj.getData()<<", Copied Data:"<<copiedObj.getData()<<endl; originalObj.setData(99); // 修改原对象不会影响到copy后的对象 cout<<"After changing Original Obj:\n"; cout<<"Original Data:"<<originalObj.getData()<<", Copied Data:"<<copiedObj.getData()<<endl; return 0; } ``` 在这个案例里,我们通过重新定义拷贝构造函数实现了真正的分离效果,即使修改其中一个也不会干扰另外一个[^3]。 --- ### 性能考量及其他注意事项 尽管深拷贝提供了更高的安全性,但它也有一定的代价。它往往需要更多的计算时间额外的空间消耗,特别是在处理大型或者复杂的嵌套结构的时候更为明显[^2]。因此,在设计阶段应当权衡利弊决定采用何种策略最为合适。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值