String COW 写时复制

最新推荐文章于 2024-03-20 21:41:59 发布
最新推荐文章于 2024-03-20 21:41:59 发布
阅读量616 收藏
点赞数
分类专栏： C++设计模式 文章标签： COW 代理模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014297722/article/details/77119821
版权
本文介绍了一种使用Copy-On-Write(COW)技术实现的C++ String类，通过额外申请空间保存引用计数来优化内存管理和提高效率。文章详细展示了String类的设计与实现，包括构造函数、析构函数、赋值操作符重载、引用计数的管理等，并通过实例演示了COW技术的工作原理。
摘要由CSDN通过智能技术生成

String 类Copy_On_Write 技术实现： 申请堆空间时额外申请sizeof(cahr)大小空间用于保存引用计数值
Proxy 模式区别operator[]运算符的write(引用计数自减) , read情况 —Effective C++

自定义一个String 类


/*
    String 类Copy_On_Write 技术实现： 申请堆空间时而外申请sizeof(cahr)大小空间用于保存引用计数值

    Proxy 模式区别operator[]运算符的write(引用计数自减) , read情况  ————Effective C++
*/

#include <stdio.h>
#include <string.h>
#include <iostream>
using std::cout;
using std::endl;

class String{
public:
    class CharProxy;         //代理类 可以设置为友元

    String();
    ~String();
    String(const char* pstr);

    String(const String &rhs);            //2种复制语义
    String & operator = (const String & rhs);

    CharProxy operator[] (size_t idx);    //重载[]
    //char & operator[](size_t idx);    //原重载的方式  返回char 类型的引用

    friend std::ostream & operator<< (std::ostream &os ,const String &rhs);

    const char* c_str() const{
        return _pstr;
    }
    size_t size() const{
        return strlen(_pstr);
    }
    size_t refcount() const{         //获取引用计数值
        return _pstr[size()+1];
    }

private:
    void initRefcount(){             //引用计数的相关函数
        _pstr[(size()+1)] = 1;
    }
    void increaseRefcount(){
        ++ _pstr[size()+1];
    }
    void decreaseRefcount(){
        -- _pstr[size()+1];
    }
    char * _pstr;
};

String::String()
:_pstr(new char [2]){
    //cout << "string()" << endl;
    initRefcount();
}

String::String(const char * pstr)
:_pstr(new char[strlen(pstr) + 2]){
    //cout << "String(const char *)" << endl;
    strcpy(_pstr,pstr);
    initRefcount();               //strcopy,初始化refcount=1
}

String::String(const String & rhs)
:_pstr(rhs._pstr){      //复制语义->浅拷贝->rhs指针赋值
    increaseRefcount();
}

String & String::operator = (const String &rhs){
    if(this != &rhs){
        decreaseRefcount();
        if(refcount() == 0){    //只有当this->refcount变为0时，才去回收左操作数的空间
            delete [] _pstr;
            cout<< "delete left _pstr" << endl;
        }
        _pstr = rhs._pstr;   //复制语义->浅拷贝->rhs指针赋值
        increaseRefcount();
    }
    return *this;       //注意返回值
}

String::~String(){
    decreaseRefcount();
    if(refcount()==0){
        delete [] _pstr;
        cout<< "~String" << endl;
    }
}

std::ostream & operator<< (std::ostream & os,const String &rhs){
    os << rhs._pstr;
    return os;
}



//*************************************CharProxy定义
class String::CharProxy{
public:
    CharProxy(String &, int );
    CharProxy & operator=(const char &);
    friend std::ostream& operator<<(std::ostream &os, const CharProxy &rhs)
    {
        return os << rhs._mystr.c_str()[rhs._idx];    //避免 _mystr[idx]递归;
    }
private:
    String & _mystr;     //********传递一个引用!!!! 代理类不需要析构函数
    size_t _idx;
};

String::CharProxy::CharProxy(String & mystr, int idx)
:_mystr(mystr)
,_idx(idx){
    cout<<"String::CharProxy::CharProxy(String & mystr, int idx)() ok"<<endl;
}

String::CharProxy & String::CharProxy::operator=(const char & c){
    if(_idx < _mystr.size()){
        if(_mystr.refcount()>1){          //待更新的str多个引用时
            _mystr.decreaseRefcount();
            char * ptmp = new char[_mystr.size()+2];
            strcpy(ptmp,_mystr._pstr);

            _mystr._pstr=ptmp;          //浅拷贝,同一块堆区
            _mystr.initRefcount();
        }
        _mystr._pstr[_idx]=c;  //写更新
    }
    return (*this);
}

//保证CharProxy定义complete  string operator需要在最后
String::CharProxy String::operator[] (size_t idx){

     return CharProxy(*this , idx);
}

int main(int argc,char** argv){
    //*****************************************************测试复制语义
    String str1;
    String str2("hello,world");
    String str3(str2);
    cout << "str1 = " << str2 << endl;
    cout << "str2 = " << str2 << endl;
    cout << "str3 = " << str3 << endl;
    cout << "str1's refcount = " << str1.refcount() << endl;
    cout << "str2's refcount = " << str2.refcount() << endl;
    cout << "str3's refcount = " << str3.refcount() << endl;
    printf("&str1 = %p\n", str3.c_str());
    printf("&str2 = %p\n", str2.c_str());
    printf("&str3 = %p\n", str3.c_str());
    cout<<"----------------------------------"<<endl;
    str1 = str2;                       //str2 str3指向的字符串 引用计数+1
    cout << "str1 = " << str2 << endl;
    cout << "str2 = " << str2 << endl;
    cout << "str3 = " << str3 << endl;
    cout << "str1's refcount = " << str2.refcount() << endl;
    cout << "str2's refcount = " << str2.refcount() << endl;
    cout << "str3's refcount = " << str3.refcount() << endl;
    printf("&str1 = %p\n", str3.c_str());
    printf("&str2 = %p\n", str2.c_str());
    printf("&str3 = %p\n", str3.c_str());
    cout<<"----------------------------------"<<endl;
    String str4 = "wangdao";
    String str5(str4);         //此时str4引用计数=2
    str4=str2;                  //此时str2 的引用计数=4
    cout << "str2 = " << str2 << endl;
    cout << "str4 = " << str4 << endl;
    cout << "str5 = " << str5 << endl;
    cout << "str2's refcount = " << str2.refcount() << endl;
    cout << "str4's refcount = " << str4.refcount() << endl;
    cout << "str5's refcount = " << str5.refcount() << endl;
    printf("&str2 = %p\n", str2.c_str());
    printf("&str4 = %p\n", str4.c_str());
    printf("&str5 = %p\n", str5.c_str());
    //*************************************************测试operator [] 写操作
    cout<<"----------------------------------"<<endl;
    str1[0] = 'X';
    cout << "str1 = " << str1 << endl;
    cout << "str2 = " << str2 << endl;
    cout << "str3 = " << str3 << endl;
    cout << "str4 = " << str4 << endl;
    cout << "str1's refcount = " << str1.refcount() << endl;
    cout << "str2's refcount = " << str2.refcount() << endl;
    cout << "str3's refcount = " << str3.refcount() << endl;
    cout << "str4's refcount = " << str4.refcount() << endl;
    printf("&str1 = %p\n", str1.c_str());
    printf("&str2 = %p\n", str2.c_str());
    printf("&str3 = %p\n", str3.c_str());
    printf("&str4 = %p\n", str4.c_str());
    //*************************************************测试operator [] 读操作
    cout<<"----------------------------------"<<endl;
    cout<<"read str2[0]"<<str2[0]<<endl;       //read str[2] 不会发生COW情况 refcout 不改变
    cout << "str1 = " << str1 << endl;
    cout << "str2 = " << str2 << endl;
    cout << "str3 = " << str3 << endl;
    cout << "str4 = " << str4 << endl;
    cout << "str1's refcount = " << str1.refcount() << endl;
    cout << "str2's refcount = " << str2.refcount() << endl;
    cout << "str3's refcount = " << str3.refcount() << endl;
    cout << "str4's refcount = " << str4.refcount() << endl;
    printf("&str1 = %p\n", str1.c_str());
    printf("&str2 = %p\n", str2.c_str());
    printf("&str3 = %p\n", str3.c_str());
    printf("&str4 = %p\n", str4.c_str());

    return 0;

}

/*
    1.思考 private static 来保存引用计数值的错误设计
    2.String 重载[]但是无法进行左值、右值判断。=》只返回代理类对象，将左值右值判断放入代理类内部,再次重载代理类的 operator<<（右值情况）与 operator=（左值情况）
*/
cuixuange
关注
专栏目录
Java 并发集合：CopyOnWrite 写时复制集合介绍
栗筝i的博客
07-02 5564
写时复制（Copy-on-Write，简称COW）是一种计算机程序设计领域的优化策略。其核心思想是：如果有多个调用者同时请求相同资源（如内存或磁盘上的数据存储），他们会共同获取相同的指针指向相同的资源，直到某个调用者试图修改资源的内容时，系统才会真正复制一份专用副本给该调用者，而其他调用者所见到的最初的资源仍然保持不变。这一过程对其他的调用者都是透明的。当对容器进行写操作（这里的写可以理解为 “增、删、改”）时，为了避免读写操作同时进行而导致的线程安全问题。
c++中类String的构造函数，赋值函数和复制函数的实现
仗劍走天涯
11-13 1257
代码如下： // test.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include <iostream> #include <string> #pragma warning(disable:4996) using namespace std; class String{ private: char *m_Stri...
String系列——写时复制COW
奔跑的小河
07-31 895
实现写时复制技术，这其中包含了引用技术原理。
Linux写时拷贝技术(copy-on-write)
weixin_33923148的博客
07-20 1003
源于网上资料 COW技术初窥：       在Linux程序中，fork（）会产生一个和父进程完全相同的子进程，但子进程在此后多会exec系统调用，出于效率考虑，linux中引入了“写时复制“技术，也就是只有进程空间的各段的内容要发生变化时，才会将父进程的内容复制一份给子进程。       那么子进程的物理空间没有代码，怎么去取指令执行exec系统调用呢？       在fork之后exe...
虚拟化， COW写时复制
weixin_33868027的博客
11-07 237
虚拟化 Virtualization 资源管理 实现程度、完全、部分、硬件辅助（cpu） virsh nodeinfo 查看KVM节点（服务器）信息 virsh list [-all] 列出虚拟机 virsh sominfo 虚拟机名称 查看指定虚拟机的信息 virsh autostart [-disable] 虚拟机名称 将指定的虚拟机设置为开...
写时复制
w5543081的专栏
12-18 1650
写时复制写时复制技术最初产生于Unix系统，用于实现一种傻瓜式的进程创建：当发出fork(  )系统调用时，内核原样复制父进程的整个地址空间并把复制的那一份分配给子进程。这种行为是非常耗时的，因为它需要： ·      为子进程的页表分配页面·      为子进程的页分配页面·      初始化子进程的页表·      把父进程的页复制到子进程相应的页中 创建一个地
Copy-on-write
No detail can be too detailed
08-25 596
写入时复制(Copy-on-write)是一个被使用在程式设计领域的最佳化策略。其基础的观念是，如果有多个呼叫者(callers)同时要求相同资源，他们会共同取得相同的指标指向相同的资源，直到某个呼叫者(caller)尝试修改资源时，系统才会真正复制一个副本(private copy)给该呼叫者，以避免被修改的资源被直接察觉到，这过程对其他的呼叫只都是通透的(transparently)。此作
String类的写时拷贝实例
08-31
在这个实例中，我们看到一个实现了一个简单的String类，它利用了"写时拷贝"（Copy-on-Write, COW）策略来提高性能。写时拷贝是一种优化技术，当对象被多个引用共享且没有写操作时，不会真正复制对象，只有在需要修改...
自己模拟写C++中的String类型实例讲解
12-31
//复制构造函数，利用String类型来初始化对象 ~String();　//析构函数 int length();　//返回String类型中字符串的长度 String & operator=(const String & s);//重载=运算符。 String & operator=(const char *); ...
写时拷贝的方式实现C++中string类
YANG
09-04 1847
写时拷贝的两种实现方式：计数器和引用计数
COW写时拷贝---快照
jasonLee的博客
11-13 1131
WIKI上对COW的解释： Copy-on-write (sometimes referred to as “COW”) is an optimization strategy used in computer programming. The fundamental idea is that if multiple callers ask for resources which are ini
写时复制COW
最新发布
luoyuhhh的博客
03-20 207
当有多个线程执行读操作时 , 那么 , 多个线程同时读取共享数据 , 但是 , 此时如果有线程需要执行写操作 , 那么就会拷贝一份数据 , 线程修改的是拷贝的数据 , 其他线程读取的是原数据 , 当线程修改完毕后 , 就会将拷贝的数据赋值给共享数据 , 后续其他线程就可以读取新数据了。● cow保证了最终一致性 , 因为在写的过程中 , 原有读的数据是不会发生更新的 , 只有写完才可以得到新数据。● cow适用于读多写少的情况 , 可以最大效率的提高读的效率 (不用频繁加锁解锁)
写时复制（COW）详解
lqycwr的博客
01-10 9946
1、写时复制简介 写时复制（Copy-on-write，简称COW）是一种计算机程序设计领域的优化策略。其核心思想是，如果有多个调用者（callers）同时请求相同资源（如内存或磁盘上的数据存储），他们会共同获取相同的指针指向相同的资源，直到某个调用者试图修改资源的内容时，系统才会真正复制一份专用副本（private copy）给该调用者，而其他调用者所见到的最初的资源仍然保持不变。这过程对其他的调用者都是透明的。此作法主要的优点是如果调用者没有修改该资源，就不会有副本（private copy）被创建，
Linux：COW 写时拷贝技术
哈尼的博客
07-16 1113
操作系统一：COW：Copy-On-Write 写时拷贝技术 1. cow 写时拷贝技术的背景1.1 传统fork()调用1.2 传统fork()调用的缺点2. cow 写时拷贝：2.1 一句话解释：虚拟地址空间独立(复制)，物理地址空间共享，只有写入时才拷贝(推迟或者避免拷贝)2.2 cow 写时拷贝技术原理2.3 cow 写时拷贝的不拷贝的情形：exec2.4 cow 应用场景 1. cow 写时拷贝技术的背景 1.1 传统fork()调用 传统的fork()系统调用直接把所有的资源复制给新创建的进
并发编程---写入时复制COW
Wulawuba的博客
04-16 968
写入时复制（copy on write） 作为使用频率很高的List和Set，JUC提供了相应的线程安全集合，就是Copy-On-Write。分别为CopyOnWriteArrayList和CopyOnWriteArraySet。 1、应用场景 Copy-On-Write并发容器用于读多写少的并发场景。 比如Nacos的注册中心同步方式，用的是copyonwrite,就是复制一份副本，写入后直接替换。注册中心的实时性并没有那么高，所以使用cow来保证数据的一致性。 Redis的COW Redis在
Delphi中复制带有String的记录结构时不能使用Move之类的内存操作函数.mht
06-10
Delphi中复制带有String的记录结构时不能使用Move之类的内存操作函数.mht
c++基础自己实现一个String类（COW）
FairLikeSnow的博客
09-15 567
写时拷贝（Copy On Write） 使用了引用计数，在开辟空间时会多开辟4个字节用来保存引用计数的值。当第一个对象构造时，String的构造函数会根据传入的参数从堆上分配内存，当有其他对象需要这块内存时，计数器++，当有对象进行析构释放时，引用计数–，直到最会一个对象被析构，此时计数器为0。只有这样程序才会真正的释放掉这块从堆上分配的内存。 #include <iostream> #include <Windows.h> #pragma warning (disable:4996
数据备份 快照技术 之第一次写时复制（COW）和写时重定向（ROW）
种花家的奋斗兔的博客
06-25 4943
数据备份 快照技术 之第一次写时复制（COW）和写时重定向（ROW） 1.快照技术 关于指定数据集合的一个完全可用拷贝，该拷贝包括相应数据在某个时间点的映像。 快照相当于给数据拍个照片 2. 第一次写时复制 COW COW(Copy-On-Write)，写时拷贝，也称为写前拷贝。 创建快照以后，如果源卷的数据发生了变化，那么快照系统会首先将原始数据拷贝到快照卷上对应的数据块中，然后再对源卷进行改写。 写操作 如上图简要示例，快照创建以后，若上层业务对源卷写数据X，X在缓存...
写时复制技术(Copy-on-write)
weixin_30419799的博客
11-05 180
COW技术初窥： 在Linux程序中，fork（）会产生一个和父进程完全相同的子进程，但子进程在此后多会exec系统调用，出于效率考虑，linux中引入了“写时复制“技术，也就是只有进程空间的各段的内容要发生变化时，才会将父进程的内容复制一份给子进程。 那么子进程的物理空间没有代码，怎么去取指令执行exec系统调用呢？ 在fork之后exec之前两个进程用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值