写时拷贝

最新推荐文章于 2024-03-03 21:19:21 发布
最新推荐文章于 2024-03-03 21:19:21 发布
阅读量853 收藏
点赞数
分类专栏： C++ 文章标签： 写时拷贝
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/quinn0918/article/details/75207973
版权

怎么样解决浅拷贝中同一块空间被释放多次？在深浅拷贝中我们提到过浅拷贝的两大缺点，并且用现代深拷贝和传统深拷贝去解决它。

当然，我们除了用深拷贝以外，常用的还有引用计数的浅拷贝。

引用计数的浅拷贝

如何实现：我们为每个内存的字符数组添加一个引用计数pcount,即就是在构造函数申请空间的时候多申请出来4个字节。表示有多少个对象使用这块内存，有多少个对象使用，就让pcount值加1，当对象被析构的时候，让pcount值减1，当pcount值为0的时候，将这块内存释放掉。当然pcount也要实现内存共享，所以它也是一个堆中的数据，每个对象都有一个指向它的指针。

但在此时,pcount的类型的选取，就会要有所考虑？

（1）如果选取int类型：（不采取）

#include<iostream>  
using namespace std;  
class String  
{  
public:  
    //构造函数  
    String(const char* ptr = "")  
    {  
        if(ptr == NULL)  
        {  
            _ptr = new char[1];  
            _pcount = 1;  
            *_ptr = '\0';  
        }  
        else  
        {  
            _pcount = 1;  
            _ptr = new char[strlen(ptr)+1];  
            strcpy(_ptr,ptr);  
        }  
    }  
    //拷贝构造函数  
    String(String& s)  
        :_ptr(s._ptr)  
        ,_pcount(s._pcount)  
    {  
        _pcount++;  
    }  
    //赋值运算符重载  
    String& operator=(const String& s)  
    {  
        if(this != &s)  
        {  
            if(--_pcount == 0)  
            {  
                delete[] _ptr;  
                //delete _pcount;  
            }  
            else  
            {  
                _ptr = s._ptr;  
                _pcount = s._pcount;  
                (_pcount)++;  
            }  
        }  
        return *this;  
    }  
    //析构函数  
    ~String()  
    {  
        if((0 == --_pcount) && _ptr!= NULL)  
        {  
            delete[]_ptr;  
            //delete _pcount;  
            _ptr = NULL;  
        }  

    }  
    //重载[]  
    char& operator[](size_t size)  
    {  
        if(--_pcount >1)  
        {  
            char* ptemp = new char[strlen(_ptr)+1];  
            int pcount = 1;  
            strcpy(ptemp,_ptr);  
            _pcount--;  
            _ptr = ptemp;  
            _pcount = pcount;   
        }  
        return _ptr[size];  
    }  
private:  
    char*_ptr;  
    int _pcount;  
};  

void FunTest()  
{  
    String s1("hello");  
    String s2(s1);  
    String s3(s2);  
    s3 = s2;  
}

测试部分：

#include<iostream>
using namespace std;
#include "String.h"
int main()
{
    FunTest();
    system("pause");
}

调试一下：
这里写图片描述
（注意这里我将断点就走到s2，意在说明问题）：本来增加s2的时候，两个对象的计数应该是一样的，但是现在一个是1，一个是2，不同步，我们了解到这两个对象的计数变量的地址是不一样的。说明此pcount是公共的，可以被多个对象同时访问。

（2）如果选取的是static类型的：（不采取） 

#include<iostream>  
using namespace std;  
class String  
{  
public:  
    //构造函数  
    String(const char* ptr = "")  
    {  
        if(ptr == NULL)  
        {  
            _ptr = new char[1];  
            _pcount = 1;  
            *_ptr = '\0';  
        }  
        else  
        {  
            _pcount = 1;  
            _ptr = new char[strlen(ptr)+1];  
            strcpy(_ptr,ptr);  
        }  
    }  
    //拷贝构造函数  
    String(String& s)  
        :_ptr(s._ptr)  
    {  
        _pcount++;  //因为是静态的，所以直接进行计数的增值就可以了  
    }  
    //赋值运算符重载  
    String& operator=(const String& s)  
    {  
        if(this != &s)  
        {  
            if(--_pcount == 0)  
            {  
                delete[] _ptr;  
                //delete _pcount;  
            }  
            else  
            {  
                _ptr = s._ptr;  
                _pcount = s._pcount;  
                (_pcount)++;  
            }  
        }  
        return *this;  
    }  
    //析构函数  
    ~String()  
    {  
        if((0 == --_pcount) && _ptr!= NULL)  
        {  
            delete[]_ptr;  
            //delete _pcount;  
            _ptr = NULL;  
        }  

    }  
    //重载[]  
    char& operator[](size_t size)  
    {  
        if(--_pcount >1)  
        {  
            char* ptemp = new char[strlen(_ptr)+1];  
            int pcount = 1;  
            strcpy(ptemp,_ptr);  
            _pcount--;  
            _ptr = ptemp;  
            _pcount = pcount;   
        }  
        return _ptr[size];  
    }  
private:  
    char*_ptr;  
    static int _pcount;  
};  
int String::_pcount = 0;  
void FunTest()  
{  
    String s1("hello");  
    String s2(s1);  
    String s3(s2);  
    s3 = s2;  
    String s4("world");  
    String s5(s4);  
}

测试部分：

#include<iostream>
using namespace std;
#include "String.h"
int main()
{
    FunTest();
    system("pause");
}

调试一下：

先走到s3，然后走到s4，用s4来构造s5,结果就不对了，走到s4的时候，计数器又变成了1，说明这5个对象公用一个pcount，不能实现引用计数。本质上说，不一样的空间应该有不一样的计数器。

（3）那么我们这样想：如果一个对象第一次开辟空间存放字符串再开辟一块新的空间存放新的额引用计数，当它拷贝构造其它对象时让其它对象的引用计数都指向存放引用计数的同一块空间，pcount设置成int*就可以。

#include<iostream>  
using namespace std;
class String
{
public:
    //构造函数  
    String(const char* ptr)
        :_ptr(new char[strlen(ptr)+1])
        ,_pcount(new int(1))
    {
        strcpy(_ptr, ptr);
    }
    //拷贝构造函数  
    String(const String& s)
        :_ptr(s._ptr)
        ,_pcount(s._pcount)
    {
        (*_pcount)++;   
    }
    //赋值运算符重载  
    String& operator=(const String& s)
    {
        if (_ptr != s._ptr)
        {
            if (--(*_pcount) == 0)
            {
                delete[] _ptr;
                delete _pcount;  
            }
            _ptr = s._ptr;
            _pcount = s._pcount;
            (*_pcount)++;
        }
        return *this;
    }
    //析构函数  
    ~String()
    {
        if (--(*_pcount) == 0)
        {
            cout << "delete[]" << _ptr << endl;//测试
            delete[]_ptr;
            delete _pcount;
            _ptr = NULL;
            _pcount = NULL;
        }

    }

private:
    char*_ptr;
    int* _pcount;
};
void FunTest()
{
    String s1("hello world");
    String s2(s1);
    String s3(s2);
    String s4(s3);

    String s5("change world");
    String s6(s5);
}

测试部分：

#include<iostream>
using namespace std;
#include "String.h"
int main()
{
    FunTest();
    system("pause");
}

调试一下：
运行结果
这里写图片描述

监视窗口：
这里写图片描述
到这里就实现了两块不一样的空间拥有不同的计数器。但是这种方式有缺陷。
缺陷一：每次new两块空间，创建多个对象的时候效率比较低
缺陷二：它多次分配小块空间，容易造成内存碎片化，导致分配不出来大块内存。

（4）还能在优化 ：仿照new的底层实现，开辟一块空间，但是它的头几个字节用于计数。

#include<iostream>  
using namespace std;  
class String  
{  
public:  
    String(char *ptr = "")  
    {  
        if(ptr == NULL)  
        {  
            _ptr = new char[strlen(ptr)+5];  
            _ptr = new char[5];  
            *(_ptr+4) = '\0';  
        }  
        else  
        {  
            _ptr = new char[strlen(ptr)+5];  
            *((int*)_ptr) = 1;  
            _ptr += 4;  
            strcpy(_ptr,ptr);  
        }  
    }  
    String(const String& s)  
        :_ptr(s._ptr)  
    {  
        (*((int*)(_ptr-4)))++;  
    }  
    String& operator=(const String& s)  
    {  
        if(this != &s)  
        {  
            if(--(*((int*)(_ptr-4))) == 0)  
            {  
                delete[]_ptr;  
            }  
            else  
            {  
                _ptr = s._ptr;  
                ++(*(int*)(_ptr-4));  
            }  
        }  
        return *this;  
    }  
    ~String()  
    {  
        if((_ptr != NULL) && ((--(*((int*)(_ptr-4)))) == 0))  
        {  
            delete[]_ptr;  
            _ptr = NULL;  
        }  
    }  
private:  
    char* _ptr;  
};  
void Funtest()  
{  
    String s1("hello");  
    String s2(s1);  
    String s3(s2);   
    s3 = s2;  
}

测试部分：

#include<iostream>
using namespace std;
#include "String.h"
int main()
{
    FunTest();
    system("pause");
}

写时拷贝

到这里就实现了引用计数的浅拷贝，引用计数的浅拷贝能够提高效率，实现浅拷贝中空间的正确释放，但是引用计数的浅拷贝的缺点也是浅拷贝的另一种缺点，就是空间的值不能被修改，会互相影响。这时候我们就用到了写时拷贝，写时拷贝也叫延时拷贝，就是当你需要改变空间的值时，我就给你单独开辟出一块空间让你去用，不需要改变空间的值时，我就不开辟。

深拷贝是直接用创建空间的方法解决了浅拷贝的两大缺点，引用计数的浅拷贝相比较深拷贝而言，不用主动创建空间，而是需要的时候才开辟空间，提高了代码的效率。

#include<iostream>  
using namespace std;
#include<assert.h>
class String
{
public:
    //构造函数  
    String(const char* ptr)
        :_pcount(new int(1))
    {
        _size = strlen(ptr);
        _capa = _size;
        _ptr = new char[_capa + 1];
        strcpy(_ptr, ptr);
    }
    //拷贝构造函数  
    String(const String& s)
        :_ptr(s._ptr)
        ,_pcount(s._pcount)
        , _size(s._size)
        , _capa(s._capa)
    {
        (*_pcount)++;   
    }
    //赋值运算符重载  
    String& operator=(const String& s)
    {
        if (_ptr != s._ptr)
        {
            if (--(*_pcount) == 0)
            {
                delete[] _ptr;
                delete _pcount;  
            }
            _ptr = s._ptr;
            _pcount = s._pcount;
            (*_pcount)++;
        }
        return *this;
    }
    void CopyOnWrite()//检测是否独占空间，否则进行处理
    {
        if (*_pcount > 1)
        {
            char *newptr = new char[_capa + 1];
            strcpy(newptr, _ptr);
            (*_pcount)--;
            _ptr = newptr;
            _pcount = new int(1);
        }
    }
    void Expand(size_t n)//扩容
    {
        if (n > _capa)
        {
            _ptr = (char*)realloc(_ptr, n + 1);
            assert(_ptr);
            _capa = n;
        }
    }
    void PushBack(char ch)//尾插一个字符
    {
        CopyOnWrite();
        if (_size == _capa)
        {
            Expand(_capa * 2);
        }
        _ptr[_size++] = ch;
        _ptr[_size] = '\0';

    }
    char& operator[](size_t pos)//可读可写
    {
        CopyOnWrite();
        return _ptr[pos];
    }
    char operator[](size_t pos) const //只读
    {
        return _ptr[pos];
    }
    const char* Getptr()
    {
        return _ptr;
    }
    void Release()//清理工作
    {
        if (--(*_pcount) == 0)
        {
            //cout << "delete[]" << _ptr << endl;//测试
            delete[]_ptr;
            delete _pcount;
            _ptr = NULL;
            _pcount = NULL;
        }
    }
    //析构函数  
    ~String()
    {
        Release();
    }

private:
    char*_ptr;
    int* _pcount;
    size_t _size;
    size_t _capa;

};
void FunTest()
{
    String s1("hello world");
    String s2(s1);
    cout << s1[0] << endl;
    cout << s1.Getptr() << endl;
    cout << s2.Getptr() << endl;

}

程序运行结果：
这里写图片描述

Quinn0918
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++写时拷贝实现原理及实例解析
08-19
主要介绍了C++写时拷贝实现原理及实例解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
写时复制（COW）详解
lqycwr的博客
01-10 8815
1、写时复制简介 写时复制（Copy-on-write，简称COW）是一种计算机程序设计领域的优化策略。其核心思想是，如果有多个调用者（callers）同时请求相同资源（如内存或磁盘上的数据存储），他们会共同获取相同的指针指向相同的资源，直到某个调用者试图修改资源的内容时，系统才会真正复制一份专用副本（private copy）给该调用者，而其他调用者所见到的最初的资源仍然保持不变。这过程对其他的调用者都是透明的。此作法主要的优点是如果调用者没有修改该资源，就不会有副本（private copy）被创建，
【Linux】写时复制（CopyOnWrite）|写时拷贝|rcu
bandaoyu的note
05-14 5199
什么是写时拷贝 写时拷贝（copy-on-write， COW）就是等到修改数据时才真正分配内存空间，这是对程序性能的优化，可以延迟甚至是避免内存拷贝，当然目的就是避免不必要的内存拷贝。
写时复制简介
最新发布
hbnn111的专栏
03-03 1018
PHP 在管理内存方面有一个机制叫写时复制（COW，Copy On Write），保证了变量间复制值不浪费内存：当一个变量的值复制到另一个变量时，PHP 没有为复制值使用更多的内存，相反，它会更新符号表来说明两个变量拥有相同的内存块，所以当执行下面的代码时并没有创建一个新的数组。写时复制技术(Copy on Write)是比较常用的一种技术，它的主要目的是延迟减少以及延迟内存的分配，增加执行效率，只有在真正进行写操作的过程中才会真正分配物理资源。相反，Java的读写锁中，读写是完全互斥的，能实现强一致性。
【写时复制（精华，从源码分析总结）】
Orwell_VII的博客
07-18 670
Linux下的fork()函数利用了写时拷贝技术，子进程复制了父进程的页表，进程“读”操作的时候也能访问到同一个数据，那是因为他们映射到的物理内存上都是一块相同的空间。但是当有一个进程要进行“写”操作时，系统会在物理内存中复制出一块内存，然后将数据写进去，进行“写”操作的进程通过虚拟地址访问时就不是访问之前的那个数据，而是访问进行“写”操作后复制过来并写入数据的那块数据----写时拷贝技术:两个进程一开始指向同一块空间，等有进程进行“写”操作时候，再给进行“写”操作的进程重新开辟空间，目的就是提高子进程创建
六、C++语言进阶：写时拷贝技术
小脑斧的博客
06-14 620
写时拷贝技术
深入理解C/C++中的写时拷贝
12-31
写时拷贝 何为写时拷贝？ 前面我说过深拷贝浅拷贝，今天我们来探究一下写时拷贝。深拷贝是补充了浅拷贝的不足，写时拷贝其实也就是补充一点深拷贝的不足。其实写时拷贝的意思就是： 当你读取到这个空间的时候，并不...
详谈Linux写时拷贝技术(copy-on-write)必看篇
09-15
下面小编就为大家带来一篇详谈Linux写时拷贝技术(copy-on-write)必看篇。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
string类写时拷贝
01-07
一种通过创建临时空间解决写时拷贝问题的方法 指路：模拟实现string类。地址：https://blog.csdn.net/MPF1230/article/details/104059562 源代码获取： https://github.com/akh5/C-/blob/master/STL/copyOnWrite.cpp...
fork函数的写时拷贝
08-10
fork函数用于创建子进程，典型的调用一次，返回两次的函数，其中返回子进程的PID和0，其中调用进程返回了子进程的PID，而子进程则返回了0，这是一个比较有意思的函数，但是两个进程的执行顺序是不定的。
写时拷贝技术
qq_41727218的博客
02-22 368
       写时拷贝的主要思想是在复制原来实体的时候，如果复制后的实体不需要进行改变，那么实际上没必要进行实体内容的拷贝，只需建立一个引用指向原来的实体内存，直接应用原来的实体内容即可，只有当需要对复制后的实体进行修改的时候才进行内容的拷贝。        写时拷贝技术在很多方面都有应用，典型的有： C++中的写时拷贝技术 Linux中的写时拷贝技术 一、C++中的写时拷贝技术     ...
写时复制
qq_38341582的博客
08-20 2791
1，什么是写时复制(Copy-On-Write)容器？ 写时复制是指：在并发访问的情景下，当需要修改JAVA中Containers的元素时，不直接修改该容器，而是先复制一份副本，在副本上进行修改。修改完成之后，将指向原来容器的引用指向新的容器(副本容器)。 2，写时复制带来的影响 ①由于不会修改原始容器，只修改副本容器。因此，可以对原始容器进行并发地读。其次，实现了读操作与写操作的分离，读操作发生在原始容器上，写操作发生在副本容器上。 ②数据一致性问题：读操作的线程可能不会立即读取到新修改的数据，因为修改操
写时复制技术
Yyb1201的博客
05-27 2110
写时复制技术 原理： 写时复制是一种计算机程序设计领域的优化策略。 其核心思想是，如果有多个调用者同时请求相同资源（如内存或磁盘上的数据存储），他们会共同获取相同的指针指向相同的资源，直到某个调用者试图修改资源的内容时，系统才会真正复制一份专用副本（private copy）给该调用者，而其他调用者所见到的最初的资源仍然保持不变。 这个过程对其他的调用者是透明的（transparently）。 优点： ⭐1、如果调用者没有修改该资源，就不会有副本被建立，因此多个调用者只是读取操作是可以共享同一份资源。 ⭐2
【C++】十五、写时拷贝
qq_43411555的博客
07-22 433
一、写时拷贝基本概念 二、设计String类的写时拷贝代码 （一）写之前浅拷贝设计 （二）写时深拷贝设计 三、代码实现 四、写时拷贝的特点
写时拷贝/写时复制技术
weixin_54355176的博客
07-01 794
深拷贝与浅拷贝，计数，写时拷贝
Redis基础 -写时复制技术
m0_58907318的博客
11-03 1890
介绍了fork在COW机制的优化情况
讲一下linux的写时拷贝
02-07
写时拷贝（Copy-on-Write，简称 COW）是一种用于管理内存的机制。它的基本思想是，当一个进程需要修改某块内存时，系统会先检查这块内存是否被其他进程共享，如果被其他进程共享，那么系统会将这块内存的副本拷贝到新的地址空间中，然后再将新的地址空间分配给修改这块内存的进程使用。这样，就避免了对共享内存的修改会导致其他进程的数据被改变的问题。 写时拷贝的好处在于，它可以有效地利用内存，同时又能保证进程间的数据独立性。例如，对于一个进程来说，它可以共享内存中的数据，这样就可以节省系统的内存空间。但是，一旦这个进程需要修改这块内存，系统就会为它分配新的内存空间，这样就可以保证进程间的数据独立性。 Linux 系统中使用写时拷贝机制的地方很多，例如，在 fork() 系统调用中，Linux 会使用写时拷贝机制来创建新进程的地址空间。这样，新进程就可以共享父进程的内存

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值