深复制与浅复制

已于 2023-03-17 11:04:40 修改
阅读量84 收藏
点赞数
分类专栏： # C/C++ 文章标签： c++ 开发语言
于 2023-03-13 17:54:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43869409/article/details/129500669
版权

浅复制及其存在的问题

对于下面的代码，在复制类（MyString）的对象时，将复制指针成员，但不复制指向的缓冲区。

其结果是，两个对象指向同一块动态分配的内存。这被称为浅复制

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

class MyString
{
private:
    char* Buffer;

public:
    //constructor
    MyString(const char* InitialInput)
    {
        if(InitialInput != NULL)
        {
            Buffer = new char [strlen(InitialInput) + 1];
            strcpy(Buffer, InitialInput);
        }
        else
        {
            Buffer = NULL;
        }
    }
    //Destructor
    ~MyString()
    {
        cout << "Invoking destructor, clearing up" << endl;
        if(Buffer != NULL)
        {
            delete [] Buffer;
        }
    }

    int GetLength()
    {
        return strlen(Buffer);
    }
    const char* GetString()
    {
        return Buffer;
    }
};

void UseMyString(MyString Input)
{
    cout << "String buffer in MyString is " << Input.GetLength();
    cout << " characters long" << endl;

    cout << "Buffer contains: " << Input.GetString() << endl;
    return;
}

int main()
{
    MyString SayHello("Hello from String Class");

    UseMyString(SayHello);
    return 0;
}

输出结果如下，程序运行出现异常：

image-20230313162303059

image-20230313162352203

因此在调用 UseMyString 函数时，将实参 Hello 传递给形参 Input，只是复制了指针成员 Buffer

此时：Hello 的 Buffer 指针和 Input 的 Buffer 指针都指向同一块保存 “Hello from String Class” 字符串的区域。

异常分析：

UserMyString(SayHello) 处的复制，根据函数定义可知是按值传递

对于整型、字符、原始指针等POD数据（Plain Old Data(关于POD)，能用 C 的 memcpy() 等函数进行操作的类、结构体就是 POD 类型的数据），编译器执行二进制拷贝（？），因此 SayHello 的 Buffer 包含的指针值被复制到 Input 中，即：

image-20230313163534517

对于此程序：

调用 UserMyString(SayHello) 结束时，会调用析构函数对 Input.Buffer 进行delete，这将导致 main() 中的 SayHello 对象指向的内存无效。

而在 main() 执行完毕时，需要对 SayHello 对象指向内存释放，但此时的 SayHello.Buffer地址值已经是无效的（UseMyString结束已经释放了）

因此未成功销毁 SayHello 对象，出现异常。

使用深复制

在编写类时，必须提供复制构造函数。每当对象被复制时（包括将对象按值传递给函数），编译器都将调用复制构造函数。

复制构造函数的语法：

class MyString
{
	MyString(const MyString& CopySource);
};

MyString::MyString(const MyString& CopySource)
{
	//Copy constructor implementation code
}

复制构造函数的参数是以引用方式传入当前类的对象。使用引用参数编写自定义实现代码，从而确保深复制。

/*
程序清单9.9：定义复制构造函数，确保对动态分配的缓冲区进行深复制
*/
#include <iostream>
#include <cstring>
using namespace std;

class MyString
{
private:
    char* Buffer;

public:
    //constructor
    MyString(const char* InitialInput)
    {
        cout << "Constructor: creating new MyString" << endl;
        if(InitialInput != NULL)
        {
            Buffer = new char [strlen(InitialInput) + 1];
            strcpy(Buffer, InitialInput);

            cout << "Buffer points to: " << hex;
            cout << (unsigned int*)Buffer << endl;
        }
        else
        {
            Buffer = NULL;
        }
    }
    //Copy constructor
    MyString(const MyString& CopySource)
    {
        cout << "Copy constructor: copy from MyString" << endl;
        if(CopySource.Buffer != NULL)
        {
            Buffer = new char [strlen(CopySource.Buffer) + 1];
            strcpy(Buffer, CopySource.Buffer);

            cout << "Buffer points to: " << hex;
            cout << (unsigned int*)Buffer << endl;
        }
        else
        {
            Buffer = NULL;
        }
    }

    //Destructor
    ~MyString()
    {
        cout << "Invoking destructor, clearing up" << endl;
        if(Buffer != NULL)
        {
            delete [] Buffer;
        }
    }

    int GetLength()
    {
        return strlen(Buffer);
    }
    const char* GetString()
    {
        return Buffer;
    }
};

void UseMyString(MyString Input)
{
    cout << "String buffer in MyString is " << Input.GetLength();
    cout << " characters long" << endl;

    cout << "Buffer contains: " << Input.GetString() << endl;
    return;
}

int main()
{
    MyString Hello("Hello from String Class");

    UseMyString(Hello);
    return 0;
}

image-20230313165940704

拷贝中的 Buffer 与 SayHello.Buffer 指向的内存地址不同，因此 UserMyString() 对 Input 的内存释放不影响 main中的 SayHello 的内存释放

总结：

  1. 复制构造函数中使用 const，可以确保不会改变指向的源对象。
  2. 复制构造函数的参数必须使用引用传递。

实现赋值运算符 =

有时候需要对类的对象通过赋值的方式进行赋值：

class MyString
{
    //....
};
MyString overwrite("who cares?");
overwrite = SayHello;

为确保深复制，需要提供复制赋值运算符：

ClassType& operator = (const ClassType& CopySource)
{
	if(CopySource != NULL)
	{
		//Ansignment operator implementation...
	}
	return *this;
}

在深复制的代码基础上，引入复制赋值运算符：

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

class MyString
{
private:
    char* Buffer;

public:
    //constructor
    MyString(const char* InitialInput)
    {
        cout << "Constructor: creating new MyString" << endl;
        if(InitialInput != NULL)
        {
            Buffer = new char [strlen(InitialInput) + 1];
            strcpy(Buffer, InitialInput);

            cout << "Buffer points to: " << hex;
            cout << (unsigned int*)Buffer << endl;
        }
        else
        {
            Buffer = NULL;
        }
    }
    
    //Copy constructor
    MyString(const MyString& CopySource)
    {
        cout << "Copy constructor: copy from MyString" << endl;
        if(CopySource.Buffer != NULL)
        {
            Buffer = new char [strlen(CopySource.Buffer) + 1];
            strcpy(Buffer, CopySource.Buffer);

            cout << "Buffer points to: " << hex;
            cout << (unsigned int*)Buffer << endl;
        }
        else
        {
            Buffer = NULL;
        }
    }
    
    //Copy assignment operator
    MyString& operator = (const MyString& CopySource)
    {
        if ((this != &CopySource) && (CopySource.Buffer != Buffer))
        {
            if (Buffer != NULL) // firstly, free original Buffer
            {
                delete [] Buffer;
            }

            Buffer = new char [strlen(CopySource.Buffer) + 1];
            strcpy(Buffer, CopySource.Buffer);
        }

        return *this;
    }
    
    //Destructor
    ~MyString()
    {
        cout << "Invoking destructor, clearing up" << endl;
        if(Buffer != NULL)
        {
            delete [] Buffer;
        }
    }

    int GetLength()
    {
        return strlen(Buffer);
    }
    // const char* GetString()
    // {
    //     return Buffer;
    // }

    // substitute GetString() 
    // such that use effectively "cout << String1 << String2 << endl;"
    operator const char* ()
    {
        return Buffer;
    }
};

int main()
{
    MyString String1("Hello ");
    MyString String2(" World");

    cout << "Before assignment: " << endl;
    cout << String1 << String2 << endl;
    String2 = String1;
    cout << "After assignment String2 = String1:" << endl;
    cout << String1 << String2 << endl;
    return 0;
}

image-20230313172431836

  1. operator const char* () 替换 GetString，以便于可以用一条 cout 输出 String1、String2
  2. 如果编写的类管理着动态资源的分配（C风格的 char*、动态数组），除了创建构造函数和析构函数，还要实现复制构造函数和复制赋值操作符
  3. 创建不允许复制的类，可以将复制构造函数、复制赋值运算符声明为私有

本文内容参考：
《21天学通C++第七版》

我飘向北方
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[C++]深复制与浅复制
weixin_60479183的博客
01-21 1347
[C++]深复制与浅复制
深拷贝与浅拷贝、深复制与浅复制
hyl1181的博客
04-18 548
深拷贝和浅拷贝最根本的区别在于是否真正获取一个对象的复制实体，而不是引用。 假设B复制了A，修改A的时候，看B是否发生变化： 如果B跟着也变了，说明是浅拷贝，拿人手短！（修改堆内存中的同一个值） 如果B没有改变，说明是深拷贝，自食其力！（修改堆内存中的不同的值） 浅拷贝（shallowCopy）只是增加了一个指针指向已存在的内存地址， 深拷贝（deepCopy）是增加了一个指针并且申请了一个新的内存，使这个增加的指针指向这个新的内存， 使用深拷贝的情况下，释放内存的时候不会因为出现浅拷贝时释
Python列表的深复制与浅复制
Kepler11的博客
02-10 1246
一、深复制与浅复制 列表是Python中自带的一种数据结构，在使用列表时，拷贝操作不可避免，下面简单讨论一下列表的深复制（拷贝）与浅复制 首先看代码： l1 = [5, 4, 3, 2, 1] # 用两种方法实现对列表l1的拷贝 l2 = l1 l3 = l1[:] print(l1) # [5, 4, 3, 2, 1] print(l2) # [5, 4, 3, 2, 1] print(l3) # [5, 4, 3, 2, 1] #修改l1 l1[0] = 9 print(l1) # [9, 4,
Python字典的深复制与浅复制
佐井白白的微笑
04-23 2711
1. Python字典浅复制 2. 深复制 1. Python字典浅复制 直接使用“=”是浅复制，比如有一个字典a，然后令b=a，这样的话当你改变b之后，a的内容也会一并改变。 2. 深复制 Python有一个copy库可以用于深复制。 import copy a = {"name":"Leo", "age":19} b = copy.deepcopy(a) 这样...
Java对象深复制与浅复制实例详解
08-30
主要介绍了 Java对象深复制与浅复制实例详解的相关资料,需要的朋友可以参考下
Java深复制与浅复制.doc
06-10
Java深复制与浅复制
理解java中的深复制和浅复制
09-02
主要帮助大家理解java中的深复制和浅复制，对java中的深复制和浅复制进行剖析，感兴趣的小伙伴们可以参考一下
javascript浅复制与深复制
01-08
浅复制与深复制只存在于引用数据类型当中 基本数据类型储存在栈内存当中 栈内存是一个萝卜一个坑 互不影响 引用数据类型储存在堆内存当中 堆内存是一片储存空间，引用数据类型存储在堆内存中的是一个内存地址 ，...
Java深复制与浅复制&Clone
05-27
NULL 博文链接：https://zzqrj.iteye.com/blog/572562
笨蛋学C++【C++基础第六弹】
YSL_Monet的博客
04-24 918
定义类需要用到关键字 class，然后指定类的名称，类的主体是包含在一对花括号中，主体包含类的成员变量和成员函数class 类名{访问修饰符（public/protected/private）:成员变量;成员函数();
C语言案例——输出 Fibonacci 数列（斐波那契数列）的前 40 项
悟道子HD
04-25 487
输出 Fibonacci 数列（斐波那契数列）的前 40 项 #include void main() { int a[40]= {1,1}; int i; printf( "%12d%12d",a[0],a[1]); for(i=2; i
C++ Primer (第五版）第八章习题部分答案
最新发布
weixin_48467622的博客
04-27 985
C++ Primer (第五版）第八章习题部分答案
CSAPP | Lab2-Bomb Lab详细解析
wangs29的博客
04-24 1271
邪恶的邪恶博士在我们班的机器上安放了大量的“二元炸弹”。二进制炸弹是一个由一系列阶段组成的程序。每个阶段都要求你在 stdin 上键入一个特定的字符串。如果你键入了正确的字符串，那么这个阶段就会被拆除，炸弹就会进入下一个阶段。否则，炸弹会通过打印“ BOOM 然后终止。当每个阶段都被拆除时，炸弹就会被拆除。我们要处理的炸弹太多了，所以我们给每个学生一个炸弹去拆除。你们的任务，你们别无选择，只能接受，就是在due date前拆除炸弹。祝你好运，欢迎加入拆弹小组！
手搓顺序表（C语言）
m0_62646213的博客
04-23 672
顺序表头插头删，尾插尾删，任意位置插入删除的实现和优劣分析
c入门基础题（3）
梦昼初
04-26 856
1、找出数组中最大元素的位置（下标值） 输入 多组测试，每组先输入一个不大于10的整数n 然后是n个整数 输出 输出这n个整数中最大的元素及下标值 样例输入 4 1 4 5 6 样例输出 6 3 #include<stdio.h> int main(){ int a[20]; int n,x=0,y,z,s,m,f; int i,j; while(scanf("%d",&n)!=EOF){ for(i=1;i<=n;i++){ scanf("%d",&y)
c++ reinterpret_cast类型转换简单实验
xie__jin__cheng的博客
04-23 975
c++ reinterpret_cat类型转换简单实验
(C++) this_thread 函数介绍
cuber-lotus的博客
04-24 1366
在C++11起，标准规定了标注的并发库。头文件为并发支持库 (C++11 起) - cppreference.com其包含线程、原子操作、互斥、条件变量和 future 的内建支持。而其中有一个namespace为，里面有四个重要的全局函数，其实现都与当前系统环境和编译器强绑定。std::this_thread 符号索引 - cppreference.comget_id()yield()返回当前线程的id。这个id是一个的内部类型。其实现依附于所在平台。
【C++】STL-vector模拟实现
2301_80277275的博客
04-24 689
vector的模拟实现，深入理解vector，深入理解深拷贝
pandas深复制和浅复制
09-23
深复制和浅复制都是用来创建pandas对象副本的方法。深复制会创建一个完全独立的新对象，包括数据和索引，而浅复制只会创建一个新的对象，但仍然共享数据和索引。这意味着在深复制中修改副本不会影响原始对象，而在浅...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值