string的写时拷贝 + cow写时拷贝

最新推荐文章于 2024-05-20 19:41:24 发布
最新推荐文章于 2024-05-20 19:41:24 发布
阅读量157 收藏
点赞数

先修改str1，再修改str2：

    /*************************************************************************
        > File Name: string_copy_on_write.cpp
        > Author:
        > Mail:
        > Created Time: 2016年03月25日 星期五 20时22分39秒
     ************************************************************************/
     
    #include <iostream>
    #include <string>
    #include <stdio.h>
    using namespace std;
     
     
    int main()
    {
        string str1 = "linux_ever";
        string str2 = str1;
     
        cout << "查看str1和str2中内容指向的地址: " << endl;
     
        printf("str1's address is %x\n", str1.c_str());
        printf("str2's address is %x\n", str2.c_str());
     
        cout << "\n输出两个string对象的值之后的内存地址：" << endl;
        cout << "str1 = " << str1 << endl;
        cout << "str2 = " << str2 << endl;
        printf("str1's address is %x\n", str1.c_str());
        printf("str2's address is %x\n", str2.c_str());
     
        cout << "\n修改了str1之后的地址：" << endl;
        str1[0] = 'u';
        printf("str1's address is %x\n", str1.c_str());
        printf("str2's address is %x\n", str2.c_str());
     
        cout << "\n修改了str2之后的地址：" << endl;
     
        str2[0] = 'w';
        printf("str1's address is %x\n", str1.c_str());
        printf("str2's address is %x\n", str2.c_str());
     
        return 0;
    }


输出：

先修改str2，再修改str1:


    /*************************************************************************
        > File Name: string_copy_on_write.cpp
        > Author:
        > Mail:
        > Created Time: 2016年03月25日 星期五 20时22分39秒
     ************************************************************************/
     
    #include <iostream>
    #include <string>
    #include <stdio.h>
    using namespace std;
     
     
    int main()
    {
        string str1 = "linux_ever";
        string str2 = str1;
     
        cout << "查看str1和str2中内容指向的地址: " << endl;
     
        printf("str1's address is %x\n", str1.c_str());
        printf("str2's address is %x\n", str2.c_str());
     
        cout << "\n输出两个string对象的值之后的内存地址：" << endl;
        cout << "str1 = " << str1 << endl;
        cout << "str2 = " << str2 << endl;
        printf("str1's address is %x\n", str1.c_str());
        printf("str2's address is %x\n", str2.c_str());
     
        cout << "\n修改了str2之后的地址：" << endl;
        str2[1] = 'u';
        printf("str1's address is %x\n", str1.c_str());
        printf("str2's address is %x\n", str2.c_str());
     
        cout << "\n修改了str1之后的地址：" << endl;
     
        str1[1] = 'w';
        printf("str1's address is %x\n", str1.c_str());
        printf("str2's address is %x\n", str2.c_str());
     
        return 0;
    }

输出结果：


 

==================================================================================================================================================================

写时拷贝的两种方案

2017年07月09日 18:07:00 Chars-1 阅读数：1885

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/m0_37956168/article/details/74898047

1. 什么是写时拷贝

写时拷贝故名思意：是在写的时候（即改变字符串的时候）才会真正的开辟空间拷贝（深拷贝），如果只是对数据的读时，只会对数据进行浅拷贝。
写时拷贝：引用计数器的浅拷贝，又称延时拷贝
：写时拷贝技术是通过"引用计数"实现的，在分配空间的时候多分配4个字节，用来记录有多少个指针指向块空间，当有新的指针指向这块空间时，引用计数加一，当要释放这块空间时，引用计数减一(假装释放)，直到引用计数减为0时才真的释放掉这块空间。当有的指针要改变这块空间的值时，再为这个指针分配自己的空间(注意这时引用计数的变化，旧的空间的引用计数减一，新分配的空间引用计数加一)。

2. string中的两种写时拷贝

一：

  1. 动态开辟两个空间一个用来存放字符串：_str，一个用来存放计数器_refCountPtr
    这里写图片描述
  2. 每次拷贝构造时(赋值运算符的重载后半段)，直接把字符串的指针付给新的String，然后给计数器加加（*_refCountPtr）++
    这里写图片描述
  3. 在释放String的时候，先对计数器减减，再判断计数器是否为零（即看是否还有指针共享此内存），若计数器为零则直接释放_str 和 _refCountPtr
  4. 在对字符串进行更改的时候(写时),就要进行深拷贝：先进行步骤3，在进行深拷贝和字符串的更改
class String//写时拷贝
    {
    public:
        String(char * str = "\0")
            :_refCountPtr(new int(1))//开辟计数器动态内存
            ,_size(strlen(str))
        {
            _capacity = _size;
            _str = new char[_capacity+1];//开辟字符串动态内存
            strcpy(_str,str);   
        }
        String(String& s)//拷贝构造
        :_str(s._str)//直接浅拷贝
        ,_refCountPtr(s._refCountPtr)
        ,_size(s._size)
        ,_capacity(s._capacity)
        {
            (*_refCountPtr)++;//但对计数器 ++
        }

        ~String()//析构
        {
            Release();
        }
        inline void Release()
        {
            if(--(*_refCountPtr) == 0)//计数器--，并判断是否为0
            {
                cout<<"~String"<<_str<<endl;
                delete[] _str；
                delete _refCountPtr;//释放    
            }
        }
        String &operator=(String &s)//重载
        {
            if(_str != s._str)//判断是否为自己给自己赋值
            {
                Release();//判断并处理this
                _str = s._str;
                _refCountPtr = s._refCountPtr;
                _size = s._size;
                _capacity = s._capacity;
                (*_refCountPtr)++;
            }
            return *this;
        }
        char *c_str() const
        {
            return _str;
        }
        //写时拷贝
        String &push_back(char ch)
        {
            char* str = new char[_capacity*2];
            strcpy(str,_str);
            //先将原来的数据保存，用于给后面重新开辟的空间赋值
            Release();//处理原来的空间
            _str = str;
            _str[_size++] = ch;
            _str[_size] = '\0';
            _capacity *= 2;
            _refCountPtr = new int(1);//
            return *this;
        }
    private:
        char *_str;
        int *_refCountPtr;
        size_t _size;
        size_t _capacity;
    };

二：

    开辟一个空间，前面4个字节为计数器count，剩下的为字符串_str的空间，用法与分开相同。
  • 1

这里写图片描述

class String
    {
    public:
        String(char *str = "\0")
            :_capacity(strlen(str))
        {
            _size = _capacity;
            _str = new char[_capacity + 5];//多开辟了4个字节
            *(int *)_str = 1；//前4个自己存放计数器
            _str += 4;          //使_str指向开辟的4个字节后的空间
            strcpy(_str,str);//拷贝字符串
        }
        String(String &s)//拷贝构造
            :_str(s._str)//直接浅拷贝
            ,_capacity(s._capacity)
            ,_size(s._size)
        {
            ++(*(int *)(_str-4));//（str前的4个字节为计数器） ++
        }
        ~String()//析构
        {
            Release();
        }   
        void Release()
        {
            if(--(*(int *)(_str-4)) == 0)//计数器-1判断是否为零
            {
                cout<<"~String "<<_str<<endl;
                delete[] (_str-4);
            }
        }
        String& operator=(String &s)//赋值重载
        {
            if(_str != s._str)//判断是否为自己为自己赋值
            {
                Release();//处理原指针（释放空间，或者计数器-1）
                _str = s._str;
                _size = s._size;
                _capacity = s._capacity;//赋值
                ++(*(int *)(_str-4));//改变先指针的计数器
            }
            return *this;
        }
        String &operator+=(char ch)//重载，会改变，会深拷贝
        {
            char* str = new char[_capacity*2 + 6];
            strcpy(str+4, _str);//先保存原字符串
            Release();//因为要重新开辟空间，所以需要处理以前的空间
            *(int *)str = 1;//新开辟的计数器置1
            _str = str + 4;
            _str[_size++] = ch;
            _str[_size] = '\0';
            _capacity *= 2;
            return *this;
        }
        String &append(const char *str)//追加字符串
        {
            size_t len = strlen(str);//方法同+=的重载
            _capacity = len + _size;
            char *tmp = new char[_capacity + 6];
            strcpy(tmp+4 ,_str);
            Release();
            *(int *)tmp = 1;
            _str = tmp + 4;
            strcpy(_str+_size, str);
            _size = _capacity;
            return *this;
        }
    private:
        char* _str;//开辟多4个，指向4个字节后的地址
        size_t _size;
        size_t _capacity;
    };

==================================================================================================================================================================

C++写时拷贝

2018年08月14日 19:57:14 _来信 阅读数：66

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/han8040laixin/article/details/81672388

一：浅拷贝
一个类，如果不写拷贝构造函数，那么它的默认拷贝构造函数为浅拷贝，浅拷贝有什么问题呢？
拿一个简单的String类举例：

class String{
public:
    String(char* str = "\0")
        :_str(new char[strlen(str)+1])
    {
        strcpy(_str, str);
    }

    ~String()
    {
        if (_str){
            delete[] _str;
        }
    }

private:
    char* _str;
void Test()
{
    String s1("hello String!");
    String s2(s1);
}

在Test函数里，我创建了s1对象，然后s2对象通过s1来拷贝构造，由于没有写拷贝构造函数，所以为浅拷贝，运行程序直接崩溃：
这里写图片描述
原因是什么呢？
这里写图片描述
因为是浅拷贝，所以两个对象的_str指针同时指向了一块空间，然后这两个对象生命周期结束时，都会调用析构函数，那么这一块空间就被析构了两次，所以会崩溃；
还有一个问题，如果改变s1对象的指针指向的空间，由于两对象的指针指向同一块空间，所以s2对象的指针所指向的空间也一块变了，这不是我们想看到的，两对象应该各是各的。
大白话总结一下浅拷贝的问题：
1.析构多次；
2.一个改变影响另一个。

二：深拷贝可以解决浅拷贝的问题
什么是深拷贝，就是我拷贝你的时候，重开一块空间，然后把你的数据复制到我的空间里，咱俩各是各的，以后就不影响了。
这里写图片描述
代码实现：

String(const String& s)
    :_str(new char[strlen(s._str)+1])
{
    strcpy(_str, s._str);
}

 

 

 

三：深拷贝要拷贝数据，代价过大（所以才有写时拷贝）

 

 


我们可以既做到浅拷贝，又能解决析构时一块空间被释放多次，那就是引用计数。

private:
    char* _str;
    int* _refCount;

_refCount指向的空间就专门用来存_str指向的空间同时被多少对象指向。

①构造对象时，new出来的空间当然只被_str指向，所以引用计数初始化为1。
这里写图片描述

    String(const char* str = "")
        :_str(new char[strlen(str) + 1])
        , _refCount(new int(1))
    {
        strcpy(_str, str);
    }

②拷贝构造时，多出来一个对象的指针指向空间，所以引用计数要加一。

这里写图片描述

    String(String& s)
    {
        this->_str = s._str;
        _refCount = s._refCount;
        ++(*this->_refCount);
    }

③ operator= 同样是需要拷贝，所以又多出来了一个对象指向空间，引用计数再加一
和拷贝构造不一样，operator=是把一个已经构造好的对象重新赋值，而拷贝构造是构造一个新对象，所以在operator之前，我们需要先考虑之前构造好的对象它的引用计数是多少？
.如果之前的对象引用计数为1，我们给又给它重新赋值，所以之前的对象的指针指向的空间就应该被释放了：
.如果之前的对象引用计数为大于1，就算重新赋值了，也还有其他对象的指针指向这块空间，所以不需要释放。
这里写图片描述

    String& operator=(const String& s)
    {
        if (this != &s)
        {
            if ((*_refCount) == 1){
                delete[] _str;
                delete _refCount;
            }
            _str = s._str;
            _refCount = s._refCount;
            (*_refCount)++;
        }
        return *this;
    }

使用引用计数，重要的是析构函数怎么写，每一次析构都要给引用计数减1，只有当引用计数为1时，才释放空间。

~String()
{
    if (--(*_refCount) == 0)
    {
        delete[] this->_str;
        delete this->_refCount;
    }
}

到目前为止，已经通过引用计数解决了浅拷贝的析构多次会崩溃的问题，但是还是没有解决一个改变影响另一个的问题。
四：通过写时拷贝来解决浅拷贝的一个改变影响另一个的问题

 


什么是写时拷贝，就是写的时候才拷贝，也就是说，你如果要改变，就需要拷贝一份，改变的是拷贝的这一份。
什么时候可能会改变String类的数据呢？

 

 

char& operator[](size_t pos)
{
    return _str[pos];
}

operator[]时，我返回引用，这样你可以通过我的返回值来改变我的_str指针指向的数据了。
写时拷贝实现：

void CopyOnWrite()
{
    if (*_refCount > 1){//如果引用计数为1，直接写不影响
        char* tmp = new char[strlen(_str) + 1];
        strcpy(tmp, _str);
        (*_refCount)--;
        str = tmp;
    }
}

接下来我把所有用户可能通过用来改变数据的接口先写时拷贝一份就好了，比如：

char& operator[](size_t pos)
{
    CopyOnWrite()；
    return _str[pos];
}
lusic01
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
String类的写时拷贝实例
08-31
在这个实例中，我们看到一个实现了一个简单的String类，它利用了"写时拷贝"（Copy-on-Write, COW）策略来提高性能。写时拷贝是一种优化技术，当对象被多个引用共享且没有写操作时，不会真正复制对象，只有在需要修改...
C++ string类的隐式共享写时拷贝实现代码
04-03
写时拷贝（Copy-on-Write，COW）则是在尝试修改对象时才进行拷贝，如果只是读取，则可以共享同一份数据，节省内存。 在C++中，我们可以通过使用`std::shared_ptr`或`std::atomic`等工具来实现这一策略。以下是一些...
【C++】String_COW(写时拷贝）
ZDF0414的专栏
09-02 879
//第一种 #define _CRT_SECURE_NO_WARNINGS #include using namespace std; class String { public: String() :_str(new char[1]) , _pRefCount(new int(1)) { _str[0] = '\0'; } String(char *str) :_str(
c++基础自己实现一个String类（COW）
FairLikeSnow的博客
09-15 536
写时拷贝（Copy On Write） 使用了引用计数，在开辟空间时会多开辟4个字节用来保存引用计数的值。当第一个对象构造时，String的构造函数会根据传入的参数从堆上分配内存，当有其他对象需要这块内存时，计数器++，当有对象进行析构释放时，引用计数–，直到最会一个对象被析构，此时计数器为0。只有这样程序才会真正的释放掉这块从堆上分配的内存。 #include <iostream> #include <Windows.h> #pragma warning (disable:4996
【Linux】写时拷贝技术COW (copy-on-write)
最新发布
Z1tai的博客
05-20 1259
肤浅的来说，加载到内存中的程序就叫做进程。但这并不完善。运行中的系统存在大量的进程，操作系统该如何管理这些进程呢？那写实拷贝技术又什么作用呢？
String系列——写时复制COW
奔跑的小河
07-31 872
实现写时复制技术，这其中包含了引用技术原理。
operator[]，识别读操作和写操作
zhangji
03-21 721
operator[]，识别读操作和写操作 转载自 https://www.cnblogs.com/meihao1203/p/8949516.html root@iZ2zee0spkwcgvz4do5kt2Z:~/docker_use/cpp_study/string_prj# cat string_operator.cpp #include<iostream> #include<...
C++ string的COW和SSO
kemaWCZ的博客
09-30 4318
还记得书本上的关于深拷贝和浅拷贝的问题吗？ 如果自己写的一个类TestClass，采用的是默认的构造函数，或者采用自定义的构造函数（但是没有实现深拷贝）。那么下面的代码： class TestClass { public: char * p; }; TestClass a; TestClass  b(a); TestClass  c = a; 上诉都是浅
c++中深浅拷贝以及写时拷贝的实现示例代码
08-29
写时拷贝（Copy-on-Write, COW）是一种优化策略，用于延迟对象的深拷贝直到真正需要修改对象时才执行。 **一、浅拷贝** 浅拷贝在拷贝构造函数或赋值运算符中仅仅复制对象的引用，而不是创建新的内存空间。这意味着...
对浅拷贝、深拷贝、写时拷贝的简单认识
01-20
3. 写时拷贝（Copy-on-Write, COW）： 写时拷贝是一种优化策略，通常用于提高效率。在浅拷贝的基础上，当对象被复制时并不立即执行深拷贝，而是共享资源。只有当其中一个对象尝试修改其内容时，才会真正进行深拷贝。...
深入理解C/C++中的写时拷贝
08-31
在C/C++编程中，写时拷贝（Copy-on-Write, COW）是一种优化策略，主要用于提高程序的性能和效率。它主要应用于对象拷贝过程中，尤其是涉及到内存分配和复制时。COW机制的核心思想是在真正需要拷贝数据之前，不进行...
C++ string的COW和SSO策略
小小的进步
03-14 1941
现代化的编译器大多数都是实现的SSO策略，我们在编码过程中不用太关注string的实现细节，但对于COW和SSO的基本概念要有基础的了解，更进一步的了解COW和SSO策略可以查看对应编译器提供的源码。
string类的写时复制COW技术（copy on write）
Worthy_Wang的博客
03-09 502
string类的写时复制COW技术（copy on write） 文章目录string类的写时复制COW技术（copy on write）@[toc]一.COW写时复制技术二.引用计数(RefCount)实现三.String类实现(无代理模式Proxy版)四.String类实现(代理模式Proxy版) 一.COW写时复制技术 string s1("s1"); string s2(s1); str...
c++中string的cow机制以及其为何在cpp11后不再被支持
x670127565的博客
02-28 2095
本文起因 今天学习《Effective STL》的时候看到条款15，里面提到了有些stl的string实现里可能会有RefCount字段做引用计数，在实验相关内容后发现该字段已经在c++11中被废弃，为了琢磨明白为什么会废弃，进行了一番搜索，最后整理为本文。 RefCount介绍 书中介绍的一种string实现如下图。 其中RefCount字段是为了在copy string对象时避免直接重新分配内存，并拷贝字符串数据而设计的。比如在下面这段代码中，str2在赋值时拷贝了str1的数据，但实际上s
stl string的COW问题
草堂
07-28 1765
在网上反复看到一些文章关于STL string的COW(copy_on_write)问题，当初为了效率的问题极可能采取这种方式。但是在最新的vs2008上实验后，发现事实并不是这样，或者已经改版了。vs出现intellisense问题，很是让人头疼..暂时查看不了basic_string的源代码，但是简单的实验就可以证明。void String_Test(){ string k =
自己实现 写时复制（cow）模式 的c++ string类型 使用了设计模式之代理模式
带着你的名字的博客
05-19 1097
实现COW（写时复制）模式的String，让其operator[]能够区分出读写操作，从而避免只读时也修改引用计数。 使用了设计模式中的 代理模式 来实现下标运算符和赋值运算符的重载，从而完整的实现COW（写时复制）。 代码实现如下： my_string.h #ifndef __MY_STRING_H__ #define __MY_STRING_H__ #include <string.h> #include <iostream> using namespace std; cl
COW(copy on write)， SSO (small string optimization)浅析
imJaron的博客
11-20 1313
有如下一段代码， 则输出结果是？ 不一样的编译器可能会有不一样的结果，原因在于所使用的引用计数方法是COW还是SSO。比如VS上结果是false, false, false, 而老版本GCC上则是true, true, false，因trs为STL标准库对string的实现方法不同。 首先要明确一点，目前的实现中，不管哪种方式string的拷贝是深拷贝的。但是如果每次都
C++ string 类 部分成员函数实现（实现COW copy-on-write）
A Light Clean Place
05-02 1179
虽然标题中说实现了·COW，但是事实上是很浪费的，并且命名也很不标准，代码也非常小学生，毕竟初学（给自己找借口.jpg），以后应该还会把这篇找出来认真修改一下的。 Mystring.h： #pragma once #ifndef _MYSTRING_H_ #define _MYSTRING_H_ #include #include using namespace std; class My
单例自动释放及string区分读写
GALENPLUS的博客
07-04 177
1、实现Line类的PIMPL模式 #include<iostream> using std::cout; using std::endl; using std::cin; class Line{ public: Line(int ,int ,int ,int); ~Line(); void Lineprint()const;
UEC++拷贝FString的值
06-01
如果你想要拷贝一个FString的值，可以使用FString的拷贝构造函数或者赋值操作符。例如： ```c++ FString OriginalString = "Hello World"; FString CopiedString1 = OriginalString; // 使用拷贝构造函数 FString ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值