【C++】浅析浅拷贝，深拷贝及写时拷贝（copy_on_write）,模拟实现String类。

最新推荐文章于 2024-04-22 23:20:41 发布
置顶 最新推荐文章于 2024-04-22 23:20:41 发布
阅读量584 收藏 1
点赞数 1
分类专栏： C++ 文章标签： c语言 c++ 浅拷贝 深拷贝 string
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sofia_m/article/details/78484465
版权

要了解C++中的浅拷贝，深拷贝，写时拷贝，我们先来根据以下步骤来逐步了解：

  • 什么是浅拷贝？ 浅拷贝会出现什么问题？ 什么是深拷贝？
  • 实现String类深拷贝-普通版
  • 实现String类深拷贝—简洁版
  • 什么是引用计数，用引用计数实现String时，引用计数可以用普通的成员变量和类的静态成员变量吗？ 为什么？
  • 完成引用计数版本的String类—该引用计数也属于浅拷贝
  • 完成COW(写时拷贝版的String)

一、什么是浅拷贝？ 浅拷贝会出现什么问题？ 什么是深拷贝？

浅拷贝：

模拟实现一段简单的浅拷贝String类

#include<ostream>

using namespace std;
//浅拷贝
class String
{
public:
    String(const char* pStr = "")
    {
        if(NULL == *pStr)
        {
            _pStr = new char[1];
            *_pStr = '\0';
        }
        else
        {
            _pStr = new char[strlen(pStr)+1];
            strcpy(_pStr,pStr);
        }
    }
    String(const String& s)
    {
        if(this != &s)
            _pStr = s._pStr;
    }

    String& operator = (const String& s)
    {
        if(this != &s)
            _pStr = s._pStr;
        return *this;
    }

    ~String()
    {
        if(NULL != _pStr)
        {
            delete[] _pStr;
            _pStr = NULL;
        }
    }

private:
    char* _pStr;
};

int main()
{
    String s1 = "hello world";
    String s2(s1);
    system("pause");
    return 0;
}

程序运行结果调试：
①创建变量s1,s2后：
这里写图片描述
②调用析构函数销毁s2时：
这里写图片描述
③调用析构函数销毁s1时：
这里写图片描述

浅拷贝存在的问题：

浅拷贝也称位拷贝，是指源对象与拷贝对象共用一份实体，仅仅是引用的变量不同（名称不同）。对其中任何一个对象的改动都会影响另外一个对象。对浅拷贝来说，编译器只是直接将指针的值拷贝过来，当多个对象共用同一块内存，当一个对象将这块内存释放掉之后，另一些对象不知道该块空间已经还给了系统，以为还有效，所以在对这段内存进行操作的时候，会发生访问违规。
【注意】：
当在一个自定义的类中，没有给出构造函数，重载赋值运算符的时候，一般编译器就会以浅拷贝的形式自动合成。

二、实现String类深拷贝-普通版

深拷贝：

深拷贝是指源对象与拷贝对象互相独立，其中任何一个对象的改动都不会对另外一个对象造成影响。

实现String类深拷贝-普通版：
#include<ostream>

using namespace std;

//深拷贝---普通版
class String
{
public:
    String(const char* pStr = "")
    {
        if(NULL == *pStr)
        {
            _pStr = new char[1];
            *_pStr = '\0';
        }
        else
        {
            _pStr = new char[strlen(pStr)+1];
            strcpy(_pStr,pStr);
        }
    }
    String(const String& s)
        :_pStr(new char[strlen(s._pStr)+1])
    {
        if(this != &s)
        {
            strcpy(_pStr,s._pStr);
        }
    }

    String& operator = (const String& s)
    {
        //这里最好使用这种创建临时变量来拷贝s的做法，再释放空间
        //目的是为了防止直接使用this指针进行操作，万一申请空间失败，就会造成内存泄漏的问题
        if(this != &s)
        {
            char* temp = new char[strlen(s._pStr)+1];
            strcpy(temp,s._pStr);
            delete[] _pStr;
            _pStr = NULL;
            _pStr = temp;
        }
        return *this;
    }

    ~String()
    {
        if(NULL != _pStr)
        {
            delete[] _pStr;
            _pStr = NULL;
        }
    }

private:
    char* _pStr;
};

int main()
{
    String s1 = "hello world";
    String s2(s1);
    system("pause");
    return 0;
}

程序运行结果并不会在崩溃：
1、
这里写图片描述
2、
这里写图片描述

三、实现String类深拷贝—简洁版

#include<ostream>
#include<stdio.h>
#include<stdlib.h>

using namespace std;

//深拷贝---简洁版
class String
{
public:
    String(const char* pStr = "")
    {
        if(NULL == *pStr)
        {
            _pStr = new char[1];
            *_pStr = '\0';
        }
        else
        {
            _pStr = new char[strlen(pStr)+1];
            strcpy(_pStr,pStr);
        }
    }
    String(const String& s)
        :_pStr(NULL)     // 一定要初始化，防止释放随机值的空间
    {
        String temp(s._pStr);
        swap(_pStr,temp._pStr);
    }

    String& operator = (const String& s)
    {
        if(this != &s)
        {
            String temp(s._pStr);
            swap(_pStr,temp._pStr);
        }
        return *this;
    }

    ~String()
    {
        if(NULL != _pStr)
        {
            delete[] _pStr;
            _pStr = NULL;
        }
    }

private:
    char* _pStr;
};

int main()
{
    String s1 = "hello world";
    String s2(s1);
    system("pause");
    return 0;
}

四、什么是引用计数，用引用计数实现String时，引用计数可以用普通的成员变量和类的静态成员变量吗？ 为什么？

方案1：普通成员变量
方案2：类的静态成员变量
方案3：引用计数

这里写图片描述

引用计数：

在引用计数中，每一个对象负责维护对象所有引用的计数值。当一个新的引用指向对象时，引用计数器就递增，当去掉一个引用时，引用计数就递减。当引用计数到零时，该对象就将释放占有的资源。

当使用方案1时，引用计数只是一个普通的成员变量，也就是每一份对象都拥有一个自己的计数器变量，在新的类对象拷贝构造和赋值的时候需要进入原来的类对象中去获取这个计数器，再进行修改，在同一个类对象之间缺乏通用性。
当使用方案2时，引用计数是一个类的静态成员变量，类的对象都共享一个计数值，例如：

String s1 = "hello";
String s2(s1);
String s3 = "world";

这时就会发现s1里的计数变量会从2变成1，被s3改变，运行下来会导致程序崩溃。

五、完成引用计数版本的String类—该引用计数也属于浅拷贝

先看一个分析图：

这里写图片描述

程序：

class String
{
public:
    String(const char* pStr = "")
    {
        if(NULL == *pStr)
        {
            _pStr = new char[1+4];
            _pStr+=4;
            *_pStr = '\0';
        }
        else
        {
            _pStr = new char[strlen(pStr)+1+4];
            _pStr+=4;
            strcpy(_pStr,pStr);

        }
        GetRef() = 1;
    }
    String(const String& s)
    {
        if(_pStr != s._pStr)
        {
            _pStr = s._pStr;
            ++GetRef();
        }
    }

    String& operator = (const String& s)
    {
        if(_pStr != s._pStr)
        {
            Release();
            _pStr = s._pStr;
            ++GetRef();
        }
        return *this;
    }

    ~String()
    {
        Release();
    }
    int& GetRef()//得到引用计数指针域里的计数值
    {
        return *((int *)_pStr-1);
    }
    void Release()//释放_pStr 空间
    {
        if(_pStr && (0 == --GetRef()))
        {
            _pStr -= 4;
            delete[] _pStr;
            _pStr = NULL;
        }
    }

private:
    char* _pStr;
};

int main()
{
    String s1 = "hello";
    String s2(s1);
    String s3 = "world";
    s3 = s2;
    system("pause");
    return 0;
}

结论：
引用计数版的浅拷贝类型String类，还存在一个问题，就是不同对象共享同一块空间，当其中一个对象改变了该内存块中的内容时，指向该内存块的所有对象的值都会被改变。

六、完成COW(写时拷贝版的String)

程序：

#include<ostream>
#include<stdio.h>
#include<stdlib.h>

using namespace std;
//copy_on_write
class String
{
public:
    String(const char* pStr = "")
    {
        if(NULL == *pStr)
        {
            _pStr = new char[1+4];
            _pStr+=4;
            *_pStr = '\0';
        }
        else
        {
            _pStr = new char[strlen(pStr)+1+4];
            _pStr+=4;
            strcpy(_pStr,pStr);

        }
        GetRef() = 1;
    }
    String(const String& s)
    {
        if(_pStr != s._pStr)
        {
            _pStr = s._pStr;
            ++GetRef();
        }
    }

    String& operator = (const String& s)
    {
        if(_pStr != s._pStr)
        {
            Release();
            _pStr = s._pStr;
            ++GetRef();
        }
        return *this;
    }

    ~String()
    {
        Release();
    }
    char& operator[](size_t index)
    {
        if(GetRef()>1)
        {
            char* temp = new char[strlen(_pStr)+1+4];
            *((int*)temp) = 1;
            temp += 4;
            strcpy(temp,_pStr);
            --GetRef();
            _pStr = temp;
        }
        return _pStr[index];
    }

    int& GetRef()
    {
        return *((int *)_pStr-1);
    }
    void Release()
    {
        if(_pStr && (0 == --GetRef()))
        {
            _pStr -= 4;
            delete[] _pStr;
            _pStr = NULL;
        }
    }

private:
    char* _pStr;
};

int main()
{
    String s1 = "hello";
    String s2(s1);
    String s3 = "world";
    s3 = s2;
    s2 = "sss";
    system("pause");
    return 0;
}
sofia_m
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【C++】c++写时拷贝Copy On Write
SuLiJuan66的专栏
10-03 1858
c++写时拷贝Copy On Write
C++ String写时拷贝（Copy On Write）
wanglelelihuanhuan的专栏
04-18 2383
Copy On Write(写时拷贝)使用了“引用计数”，开辟空间时会多开4个字节用于保存引用计数的值。当第一个对象构造时，string的构造函数会根据传入的参数从堆上分配内存，当有其它对象需要这块内存时，这个计数为自动累加，当有对象析构时，引用计数会减一，直到最后一个对象析构，此时的引用计数为0，此时，程序才会真正的Free这块从堆上分配的内存。 引用计数就是string类中写时拷贝的原理！#
标准C＋＋类string的Copy-On-Write技术（二）
热门推荐
陈皓专栏　【空谷幽兰，心如皓月】
06-23 1万+
2.2、         深入在深入这前，通过上述的演示，我们应该知道在string类中，要实现写时才拷贝，需要解决两个问题，一个是内存共享，一个是Copy-On-Wirte，这两个主题会让我们产生许多疑问，还是让我们带着这样几个问题来学习吧：1、  Copy-On-Write的原理是什么？2、  string类在什么情况下才共享内存的？3、  string类在什么情况下触发写
C++之写时复制(CopyOnWrite)
最新发布
红军不怕远征难，万水千山只等闲
04-22 1366
CopyOnWrite允许多个对象共享相同的数据，避免了不必要的数据复制。这对于大型数据结构或多个对象需要引用相同数据的情况下，可以节省大量的内存。对于很少修改数据的情况下，CopyOnWrite可以显著提高性能。由于读操作不需要加锁，多个线程可以同时访问共享数据，提高并发访问的效率。对于一些读多写少的数据，写入时复制的做法就很不错，例如配置、黑名单、物流地址等变化非常少的数据，这是一种无锁的实现。可以帮我们实现程序更高的并发。减少数据拷贝。
【C++】写时拷贝技术（copy-on-write）
PinkBananA_的博客
07-19 920
写时拷贝的思想是在复制原来的内容时，如果复制后不会对原来的内容做出改变（即只读），就不会直接复制过去，而是建立一个指针指向原来的内存，也就是浅拷贝。如果要修改原来内存上的内容，就需要重新分配内存并将原来内存上的内容拷贝到新内存上，再进行修改，即深拷贝。 1.C++的写时拷贝技术 C++中的写时拷贝技术是通过“引用计数”来实现的。也就是说，在每次分配内存时，会多分配4个字...
C++的Copy-On-Write技术（一）
anbenjamin的博客
08-20 739
记录贴，感谢各位大佬，禁止转载的话联系我删即可。 STL，string，20200820收录 https://www.cnblogs.com/bigben0123/p/3612943.html
详解C++中String类模拟实现以及深拷贝浅拷贝
08-28
主要介绍了详解C++中String类模拟实现以及深拷贝浅拷贝的相关资料,希望通过本文能帮助到大家，让大家实现这样的方法，需要的朋友可以参考下
C++ string类的隐式共享写时拷贝的实现及设计要点
12-22
　一、为什么要实现隐式公享写时拷贝 　试想一下，如果我们要自己实现一个string类，简单的方式是什么？是让每一个string类的实例维护一个在内存中独立的字符数组，每个string对象各不相干。这样一个对象的任何...
C++浅拷贝与深拷贝及引用计数分析
08-30
C++浅拷贝与深拷贝及引用计数分析 C++浅拷贝与深拷贝及引用计数分析是C++开发中经常遇到的问题之一，浅拷贝会导致double free、内存泄露等严重的问题。在C++类中，如果成员变量包括指针，而又没有定义自己的拷贝...
C++写时拷贝实现原理及实例解析
08-19
C++写时拷贝实现原理及实例解析 写时拷贝是一种计算机程序设计领域的优化策略，其核心思想是，如果有多个调用者同时请求相同资源（如内存或磁盘上的数据存储），他们会共同获取相同的指针指向相同的资源，直到某个...
浅析C++写时复制机制（copy-on-write）
github_39553168的博客
08-05 1356
写时复制一般是用来节省内存的使用，一般的应用场景在于对象的使用大多的读操作而写操作很少，但是对象又涉及到内存的分配而且需要频繁拷贝对象。这时候写时复制就有大用处了。 MFC中的CString就用到了写时复制，当对一个CString进行拷贝时只是拷贝内部的字符串指针。 下面可以看一下CString的拷贝构造函数实现 CSimpleStringT(_In_ const CSimpleStringT& strSrc) { CStringData* pSrcData = strSrc.Ge.
标准C＋＋类string的Copy-On-Write技术（三）
mader的专栏
08-13 1071
2.3.4、      Copy-On-Write的具体实现是怎么样的？ 最后的这个问题，我们主要解决的是那个“民主集中”的难题。请先看下面的代码：  string h1 = “hello”; string h2= h1; string h3;
C++类提高篇-自定义copy-on-write方式的mystring类
quietbxj的博客
02-19 112
C++自定义copy-on-write方式的mystring类 #include <crtdbg.h> #include <iostream> #pragma warning(disable:4996) using namespace std; namespace space2 { class MyString { public: MyString(const char* tmpch=""): pvalue(new StringValue(tmpch)) {
写时拷贝(copy on write)
weixin_57023347的博客
07-17 1301
适用于深拷贝提高效率的一种方法。 例如string类，在拷贝构造时，会要用到深拷贝。如果用浅拷贝，会导致两对象的指针指向同一块空间，导致对象析构时，导致同一块空间释放两次，程序奔溃。深拷贝是在对象再开一块空间，将值拷贝过去，再让新对象的指针指向新开辟的空间。 深拷贝运用写时拷贝时，不会立马申请空间。它是一开始先让新的对象的指针先同时指向同一块空间。在读的时候或者是写的时候再在堆上申请空间给对象。 这里引入了一个引用计数：用来记录资源使用者...
c++---了解c++中浅拷贝,深拷贝,引用计数,写时拷贝以及c++中string类的模拟实现
啦~啦~啦~的博客
04-15 290
以下我们都用string类来说明。 一. 浅拷贝    首先我们来说一说浅拷贝，浅拷贝是什么呢？浅拷贝就是指将拷贝时只将指针拷贝过来了，和被拷贝的内容指向的是同一块空间。这样就会出现不想要的结果。 当有一个指针想要对其这块空间进行修改，那么这时，并不是只有一个指针指向这里，而还有别的指针。所以这里是一块共享的内存空间，那么有其中一个对其改变，其余指针的内容也将受到影响，这样就会影响其它...
写时复制Copy-On-Write
qq_26993175的博客
05-05 905
1、什么是写时复制(Copy-On-Write)容器 “在并发访问的情景下，当需要修改JAVA中Containers的元素时，不直接修改该容器，而是先复制一份副本，在副本上进行修改。修改完成之后，将指向原来容器的引用指向新的容器(副本容器)”。 2、特点 a、应用于读多写少的环境。由于不会修改原始容器，只修改副本容器。因此，可以对原始容器进行并发地读。其次，实现了读操作与写操作的分离，并发读取在原始容器上，而写操作发生在副本上。在写操作时，需要复制一个容器，实际应用场景中，内存开销大小取决于原始容器大小，可
写时拷贝技术：Copy-On-Write
yzcwansui的博客
06-12 369
概念 Copy-On-Write是一种技术——去高效的完成“懒惰行为”。其核心思想就是：只有在需要分配内存的时候才会进行内存分配。这种思想广泛的运用在操作系统和C++编程中。 在操作系统当中，当一个程序运行结束时，操作系统并不会急着把其清除出内存，原因是有可能程序还会马上再运行一次，而只有当内存不够用了，才会把这些还驻留内存的程序清出。这样既尽可能地减少了CPU读取磁盘的次数，又可以保证功能的...
C++：Copy-On-Write技术以及string类的模拟实现
zw的博客
05-14 786
文章目录1. 1.
c++ 用深拷贝和浅拷贝来实现“写时复制” copy on write
04-02
“写时复制”(Copy-On-Write，简称COW)是一种延迟复制的技术。它的基本原理是：如果有多个对象共享同一个资源，只有当其中某个对象试图修改资源时，才会真正地进行复制，以保证修改操作不会影响到其他对象。 深拷贝...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值