C++中的深浅拷贝和写时拷贝

最新推荐文章于 2022-07-11 10:11:48 发布
最新推荐文章于 2022-07-11 10:11:48 发布
阅读量430 收藏
点赞数
分类专栏： C++ 文章标签： string
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tzy5210/article/details/60766932
版权

浅拷贝

先来看一段代码：

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <string.h>
using namespace std;
class String
{
public:
    //构造函数
    String(const char *_pstr = "")
        :m_iSize(strlen(_pstr)+1)
    {
        m_pstr = new char[m_iSize];
        m_pstr[m_iSize] = '\0';
    }
    //拷贝构造函数
    String(const String& _string)
        :m_iSize(_string.m_iSize)
    {
        if (this != &_string)
        {
            m_pstr = _string.m_pstr;
        }
    }

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

private:
    char* m_pstr;
    int m_iSize;
};

void Funtest()
{
    String s1("hello world");
    String s2(s1);
}

int main()
{
    Funtest();
    return 0;
}

String s1(“hello world”);
调用String类的构造函数，将形参的内容拷贝到m_pstr中。
String s2(s1);
调用String类的拷贝构造函数，让m_pstr指向形参m_pstr空间。
接着函数向下执行，先析构s2，将s2.m_pstr所指向的空间释放，接下来释放s1，s1一直指向所申请空间，m_pstr已经为空，又去调析构函数去释放，程序崩溃。
这里写图片描述
注意：
当类里面有只针对象的时候，拷贝构造和赋值运算符重载值进行值拷贝（浅拷贝），两个对象同时指向同一块内存，对象销毁时该空间被释放了2次，程序崩溃。

深拷贝

简单的来说，【浅拷贝】是增加了一个指针，指向原来已经存在的内存。而【深拷贝】是增加了一个指针，并新开辟了一块空间，让指针指向这块新开辟的空间。
这里写了3个版本
1.普通版2.简洁版3.引用计数

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

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

    String(const String& s)
    {
        char* pTemp = new char[strlen(s._pStr) + 1];
        strcpy(pTemp, s._pStr);
        _pStr = pTemp;
    }

    String& operator=(const String& s)
    {
        if (this != &s)
        {
            char* pTemp = new char[strlen(s._pStr) + 1];
            strcpy(pTemp, s._pStr);
            _pStr = pTemp;
        }
        return *this;
    }
    String& operator+(const String& s)
    {
        char* _pCutStr = _pStr;
        char* _pSCurStr = s._pStr;
        char* Temp = new char[my_strlen(_pCutStr) + my_strlen(_pSCurStr) + 1];
        my_strcpy(Temp, _pCutStr);
        my_strcat(Temp, _pSCurStr);
        _pStr = Temp;
        return *this;
    }
    //String& operator+(const String& s, size_t pos, size_t n);
    bool operator>(const String& s)
    {
        if (this->Compare(s) > 0)
            return true;
        else
            return false;
    }
    bool operator<(const String& s)
    {
        if (this->Compare(s) < 0)
            return true;
        else
            return false;
    }
    bool operator==(const String& s)
    {
        if (this->Compare(s) == 0)
            return true;
        else
            return false;
    }
    String Copy(const String& s)
    {
        char* _pTstr = _pStr;
        char* sor = s._pStr;
        while (*_pTstr++ = *sor++)
        {
        }
        return *this;
    }
    String Copy(const String& s, size_t n)
    {
        char* _pTstr = _pStr;
        char* sor = s._pStr;
        while ((n--) && (*_pTstr++ = *sor++))
        {
        }
        return *this;
    }
    String StrStr(const String& s)
    {
        String cp;
        cp._pStr = (char *)_pStr;
        String s1, s2;

        if (!*s._pStr)
            return((char *)_pStr);

        while (*cp._pStr)
        {
            s1._pStr = cp._pStr;
            s2._pStr = (char *)s._pStr;

            while (*s1._pStr && *s2._pStr && !(*s1._pStr - *s2._pStr))
            {
                s1._pStr++; 
                s2._pStr++;
            }

            if (!*s2._pStr)
                return(cp._pStr);
            cp._pStr++;
        }

        return(NULL);
    }
private:
    int Compare(const String& s)
    {
        char* src = _pStr;
        char*dst = s._pStr;
        int ret = 0;
        while (!(ret = *(unsigned char *)src - *(unsigned char *)dst) && *dst)
        {
            ++src;
            ++dst;
        }
        if (ret < 0)
            ret = -1;
        else if (ret > 0)
            ret = 1;

        return(ret);
    }
    int my_strlen(char* _pStr)
    {
        char* _pTstr = _pStr;
        int lenth = 0;
        while (*_pTstr++)
        {
            ++lenth;
        }
        return lenth;
    }

    char* my_strcpy(char* dec,const char* sor)
    {
        char* _pTstr = dec;
        while (*_pTstr++ = *sor++)
        {}
        return _pTstr;
    }

    char* my_strcat(char* dec, const char* sor)
    {
        char* _pTstr = dec;
        while (*_pTstr)
        {
            _pTstr++;
        }
        while (*_pTstr++ = *sor++)
        {
            ;
        }
        return _pTstr;
    }

private:
    char* _pStr;
};

ostream& operator<<(ostream& _cout, String& s)
{
    _cout << s._pStr;
    return _cout;
}

void FunTest()
{
    String str1 = "hello world";
    String str2 = "delete";
    bool ret = str1 > str2;
    String str3;
    cout << str1.StrStr(str2) << endl;
}

深拷贝——简洁版
class String
{
public:
    String(const char* pStr = "")
    {
        if (NULL == pStr)
        {
            char* pTemp = new char[1];
            _pStr = pTemp;
            *_pStr = '\0';
        }
        else
        {
            char* pTemp = new char[strlen(pStr) + 1];
            _pStr = pTemp;
            strcpy(_pStr, pStr);
        }
    }

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

    String(const String& s)
    {
        String pTemp(s._pStr);
        _pStr = NULL;
        std::swap(_pStr, pTemp._pStr);  
    }

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

private:
    char* _pStr;
};

void FunTest()
{
    String str1 = "hello";
    String str2 = str1;
    String str3="word";
    String str4=str3;
    str3 = str2;
}

浅拷贝优化-引用计数
class String
{
public:
    friend ostream& operator<<(ostream& _cout, String& s);
    String(const char* pStr = "")
    {
        if (NULL == pStr)
        {
            char* pTemp = new char[1];
            _pStr = pTemp;
            *_pStr = '\0';
        }
        else
        {
            char* pTemp = new char[strlen(pStr) + 1 + 4];
            *(int*)pTemp = 1;
            _pStr = (char*)((int*)pTemp + 1);
            strcpy(_pStr, pStr);
        }
    }

    ~String()
    {
        char* temp = (char*)((int*)_pStr - 1);
        if (--*(int*)temp == 0)
        {
            delete[] temp;
            _pStr = NULL;
        }
    }

    String(const String& s)
    {
        char* temp = (char*)((int*)s._pStr - 1);
        *(int*)temp += 1;
        _pStr = s._pStr;
    }

    String& operator=(const String& s)
    {
        if (this != &s)
        {
            char* temp = (char*)((int*)_pStr - 1);
            if (--*(int*)temp == 0)
            {
                delete[] temp;
                _pStr = NULL;
            }
            _pStr = s._pStr;
            *((int*)_pStr - 1) += 1;
        }
        return *this;
    }

private:
    char* _pStr;
};

ostream& operator<<(ostream& _cout, String& s)
{
    _cout << s._pStr;
    return _cout;
}


void FunTest()
{
    String s1;
    String s2 = "hello";
    String s3 ="word";
    /*String s4 = s3;*/
    s3 = s2;
    cout << s3 << endl;
    /*cout << s4 << endl;*/
}

int main()
{
    FunTest();
    system("pause");
    return 0;
}

写时拷贝

顾名思义，写时拷贝就是在需要修改这块空间的内容时才分配一块空间。同样用上边的例子，写时拷贝会存在一个计数器，并且多个对象指向同一块空间，每次创建一个新的对象时，计数器++，销毁时计数器 - -

写时拷贝
class String
{
public:
    friend ostream& operator<<(ostream& _cout, String& s);
    String(const char* str = "")
    {
        if (NULL == str)
        {
            char* pTemp = new char[1];
            *pTemp = '\0';
            _pStr = pTemp;
            int* pCTemp = new int(1);
            _pCount = pCTemp;
        }
        else
        {
            char* pTemp = new char[strlen(str) + 1];
            strcpy(pTemp, str);
            _pStr = pTemp;
            int* pCTemp = new int(1);
            _pCount = pCTemp;
        }
    }
    ~String()
    {
        if (--(*_pCount) == 0)
        {
            delete[] _pStr;
            _pStr = NULL;
            delete _pCount;
            _pCount = NULL;
        }
    }
    String(const String& str)
    {
        _pStr = str._pStr;
        _pCount = str._pCount;
        (*_pCount)++;
    }
    String& operator=(const String& str)
    {
        if (this != &str)
        {
            if (--(*_pCount) == 0)
            {
                delete[] _pStr;
                _pStr = NULL;
                delete _pCount;
                _pCount = NULL;
            }
            _pStr = str._pStr;
            _pCount = str._pCount;
            (*_pCount)++;
        }
        return *this;
    }
private:
    char* _pStr;
    int* _pCount;
};

ostream& operator<<(ostream& _cout, String& s)
{
    _cout << s._pStr;
    return _cout;
}


void FunTest()
{
    String s1 = "hello";
    cout << s1 << endl;
    String s2 = s1;
    cout << s2 << endl;
    String s3 = "word";
    s3 = s2;

}
Delete&_all
关注
专栏目录
【c++】深拷贝、浅拷贝和写时拷贝
qq_43412060的博客
07-18 428
1、浅拷贝 2、深拷贝 3、写时拷贝 3.1设计思想 3.2具体实现 3.3引用计数的不足
C++中的深浅拷贝
pigdwh的博客
09-01 1310
C++中的深浅拷贝 参考博客：https://blog.csdn.net/feitianxuxue/article/details/9275979 一：构造函数: 概念：构造函数是一种随着对象创建而自动被调用的公有成员函数，有且仅在定义对象时自动执行一次，它的主要用途是为对象作初始化（初始化只能有一次）。 特征: 1:函数名和类名相同； 2：无返回值； 3：对象构造时（对象实例化）系...
浅析C++深浅拷贝、写时拷贝
qq_43560037的博客
04-05 1483
深or浅拷贝？ 深浅拷贝前言一、深浅拷贝哪家强？二、写时拷贝总结 前言 之前我们在浅谈6个成员函数中有提到深浅拷贝的问题，现在再回首掏一把。 一、深浅拷贝哪家强？ 先给出代码理一理 #define _CRT_SECURE_NO_WARNINGS 1 #include <iostream> #include<assert.h> using namespace std; class String { friend ostream& operator<<(os
c++中的深浅拷贝
qq_24093081的博客
07-11 226
深浅拷贝
c++中深浅拷贝以及写时拷贝的实现示例代码
08-29
总结起来，C++中的深浅拷贝和写时拷贝都是关于如何正确地管理对象复制和内存的策略。深拷贝确保了每个对象都有独立的内存，而浅拷贝和写时拷贝则是在效率和数据一致性之间做出权衡。理解这些概念对于编写健壮和高效...
08_26_C++ 深浅拷贝的区别
07-01
08_26_C++ 深浅拷贝的区别08_26_C++ 深浅拷贝的区别08_26_C++ 深浅拷贝的区别08_26_C++ 深浅拷贝的区别08_26_C++ 深浅拷贝的区别08_26_C++ 深浅拷贝的区别08_26_C++ 深浅拷贝的区别08_26_C++ 深浅拷贝的区别08_26_...
【C++ STL】string 容器（介绍、使用、深浅拷贝、模拟实现、写时拷贝）
codewinter的博客
05-22 1645
文章目录前言一、STL - string 的介绍二、string 的使用（常用接口介绍）2.1 常见构造2.2 容量操作2.3 访问操作2.4 迭代器及遍历操作2.5 修改操作2.6 string 类的非成员函数重载2.7 补充一些接口三、string 类的模拟实现3.1 深浅拷贝（⭐重要）① 浅拷贝 & 深拷贝② 拷贝构造 & 赋值运算符重载（传统写法）③ 拷贝构造 & 赋值运算符重载（现代写法）3.2 string 类的结构3.3 string 类的迭代器3.4 一些成员函数的实
浅述python中深浅拷贝原理
12-25
在c++中参数传递有两种形式：值传递和引用传递。这两种方式的区别我不在此说，自行补上，如果你不知道的话。我先上python代码，看完我们总结一下，代码如下： # copy module import import copy # number and ...
C++_深浅拷贝
Gentleman_ZH
11-17 205
一、何时调用拷贝构造函数 1、对象在创建时使用其他的对象初始化       Person p(q); //此时复制构造函数被用来创建实例p       Person p = q; //此时复制构造函数被用来在定义实例p时初始化p 2、对象作为函数的参数进行值传递时     f(p); //此时p作为函数的参数进行值传递，p入栈时会调用复制构造函数创建一个局部对象，与函数内的局部变量具有相同的...
C++（笔记）深浅拷贝and何时调用
浅然的专栏
03-23 2010
一、何时调用拷贝函数 何时会调用拷贝函数？ 1、对象在创建时使用其他的对象初始化 Person p(q); //此时复制构造函数被用来创建实例p Person p = q; //此时复制构造函数被用来在定义实例p时初始化p 2、对象作为函数的参数进行值传递时 f(p); //此时p作为函数的参数进行值传递，p入栈时会调用复制构造函数创建一个局部对
c++写时拷贝
aby_byy的博客
02-02 173
c++ 写时拷贝： 当一个拷贝构造一个需要动态开辟内存空间的对象时，用浅拷贝就会出现空间被释放两次的情况，这样显然会出现问题，用深拷贝的话就可以解决此问题，但是每一次不管它用不用都是有空间被申请，这样就很浪费。举个不恰当的例子: 就比如一块蛋糕，你就坐一边看着也不吃就那样放着，来了第二个人的话，同样的蛋糕同样不吃在那看着，就需要重新拿一块，这样两个人，两个蛋糕，大家都不吃在那只是盯着预备着就很...
C++写时拷贝
来信
08-14 1645
一：浅拷贝 一个类，如果不写拷贝构造函数，那么它的默认拷贝构造函数为浅拷贝，浅拷贝有什么问题呢？ 拿一个简单的String类举例： class String{ public: String(char* str = &amp;quot;\0&amp;quot;) :_str(new char[strlen(str)+1]) { strcpy(_str, str); } ...
C++ 写时拷贝
Fly_bit的博客
07-11 438
首先来了解浅拷贝和深拷贝： 1、浅拷贝，是指原对象与拷贝对象共用一份实体，仅仅是对象名字不同而已（类似引用，即对原对象起别名），其中任何一个对象的改变都会导致其他的对象也跟着改变。2、深拷贝，是指拷贝一块跟原对象大小一样的数据块，即给新对象重新开辟一块空间，并将原对象的内容拷贝下来，这样原对象和现有对象指向各自的数据块，析构时释放各自的数据块。3、写时拷贝（Copy On Write）：给类增加一
C++中的写时拷贝
zhuoya_的博客
06-09 872
一、什么是写时拷贝？就是当你再读取一片空间时，系统并不会为你开辟一个一模一样的空间给你；只有在当你真正修改的时候，才会开辟一片空间给你。二、怎么实现写时拷贝呢？（1）、使用引用计数来实现。所有我们在分配空间时需要多分配4个字节，来记录有多少个指针指向这个空间。（2）、有新的指针指向这篇空间时，那么引用计数就加一；当有一个指针要释放该空间时，那么引用计数就减一。（3）、当有指针要修改这片空间时，则为...
C++:写时拷贝
aixintianshideshouhu的博客
05-11 199
一、浅拷贝 一个类，如果不写拷贝构造函数，那么它的默认拷贝构造函数是浅拷贝，浅拷贝有什么问题呢？ 用一个string来举例： class String { public: String(char* str = "\0") :_str(new char[strlen(str)+1]) { strcpy(_str, str); } ~String() { if(_str) ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值