深浅拷贝以及引用计数

最新推荐文章于 2022-04-12 19:28:16 发布
最新推荐文章于 2022-04-12 19:28:16 发布
阅读量370 收藏 2
点赞数 2
分类专栏： c和c++语言 文章标签： string 引用计数 写时拷贝 深浅拷贝
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34992845/article/details/60648765
版权

标准库类型string表示可变长的字符序列，使用string类型必须首先包含它的头文件。
作为标准库的一部分，string定义在命名空间std中。

#include<string>//注意这里没有.h
using namespace std;

下面让我们一起来模拟string类中的几个比较重要的成员函数，一步一步的剖析它们的实现机制：

1.构造函数：

示例①

class String
{
public :
    String(char *str = "")//construction function
        :_str(str)
    {}
    ~String()
    {
        if (NULL != _str)
        {
            delete[] _str;
        }
    }
private :
    char *_str;
};

void Test2()
{
    String s1("hello");
    String s2(new char[3]);
}

这里写图片描述

从监视窗口可以看出，s1貌似构建成功了，但是在Test2()快要结束时，程序崩溃了，我们知道，析构函数是在对象销毁前执行的，
所以程序崩溃的原因就是执行析构函数的时候，析构函数中释放对象中指针_str指向的空间，
但是S1中指针_str指向的是一个常量字符串—->存放在代码区（c语言）或者说常量区（操作系统）,而delete[]释放的空间必须要是动态分配的，至此我们就可知程序崩溃的原因。

经过上例的讨论，我将构造函数做了些许的修改：
示例②：

class String
{
public :
    String(char *str = "")//构造函数
    {
        if (NULL == str)
        {
            _str = new char[1];//为了和delete[]配合使用
            *_str = '\0';
        }
        else
        {
            _str = new char[strlen(str) + 1];
            strcpy(_str, str);
        }
    }

    ~String()
    {
        if (NULL != _str)
        {
            delete[] _str;
        }
    }
private :
    char *_str;
};

构造函数的参数列表带有默认值也是为了和类库中的一致，当以string s1;形式构造对象时，希望构造出的字符串为空串（含有’\0’）。

2.拷贝构造函数：

①浅拷贝：

String::String(const String& s)//浅拷贝
:_str(s._str)
{}

测试：

void Test2()
{
    String s1("hello");
    String s2(s1);
}

上面的程序会崩溃，下面我们来分析原因：
这里写图片描述

可以看出这里的s2采用了浅拷贝，而析构的时候，先析构的是s2,析构s2时会释放掉“hello”这块空间，接下来再释放s1时，程序就会崩溃，因为这块空间被释放了两次。

浅拷贝：又称为位拷贝，编译器只是将指针的内容拷贝过来，导致多个对象共用一块内存空间，当其中任意对象将这块空间释放之后，另外一些对象并不知道这块空间已经还给了操作系统，以为还有效，所以再对这块空间进行操作时，造成了违规访问。

为了解决这个问题，我们引入了深拷贝（给要拷贝构造的对象重新分配空间）：

这里写图片描述

代码如下：

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

测试：

void Test2()
{
    String s1("hello");
    String s2(s1);
}

这里写图片描述

由监视窗口可知，拷贝的对象s2中_str的值（字符串的地址）和s1对象中的_str的值不同，说明是重新开辟了空间（即就是深拷贝）。

3.赋值运算符重载：

//方法①
String& String::operator=(const String& s)
{
    if (this != &s)
    {
        delete[] _str;
        _str = new char[strlen(s._str) + 1];
        strcpy(_str, s._str);
    }
    return *this;//为了支持链式访问
}

//方法②（优）
String& String::operator=(const String& s)
{
    if (this != &s)
    {
        char* tmp = new char[strlen(s._str) + 1];
        strcpy(tmp, s._str);
        delete[] _str;
        _str = tmp;
    }
    return *this;//为了支持链式访问
}

测试：
这里写图片描述

一般情况下，上面的两种写法都可以，但是相对而言，第二种更优一点。
对于第一种，先释放了旧空间，但是如果下面用new开辟新空间时有可能失败——>抛异常，而这时你是将s2赋值给s3,不仅没有赋值成功（空间开辟失败），而且也破坏了原有的s3对象。

对于第二种，先开辟新空间，将新空间的地址赋给一个临时变量，就算这时空间开辟失败，也不会影响原本s3对象。

综上：第二种方法更优一点。

最后的返回值是为了支持链式访问。
例如：s3 = s2 = s1;

上面所写的拷贝构造函数和赋值运算符重载函数属于传统写法，下面我们一起来看看它们的现代写法：

拷贝构造的现代写法：
这里写图片描述

赋值运算符重载函数的两种现代写法：

这里写图片描述
在面试时，一般写出上面四个string类的成员函数即可，除非面试官特别要求。

从上面的深拷贝我们可以看出，相比浅拷贝，深拷贝的效率明显较低，因为每拷贝一个对象就需要开辟空间和释放空间，再有就是赋值运算符重载也是一样的需要重新开辟空间并释放空间。
假如有这样的一种情况，拷贝和赋值得到的对象只用于”读”,而不用于”写”，那么是不是就不需要重新开辟空间了呢？

下面让我们一起来了解一下引用计数的浅拷贝：

我们需要使用一个变量可以标记同一块空间同时有几个对象在使用—–>为了析构（当标记的这个变量为1时，说明只有一个对象在使用这块空间，那么在使用完成后就可以去释放空间，否则让这个计数的变量减1）。
引用计数的浅拷贝：

首先，我们需要讨论下这个所谓的计数变量：
①使用数据成员 int _count;
在构造函数中使得_count = 1;
在拷贝构造函数中_count(++s._count).
但是析构的时候无法改变每个对象中的_count的值。

String.h

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;

class String
{
public:
    String(const char* str = "");
    String(String& s);
    String& operator=(const String& s);
    ~String();
private:
    int& GetRef(char *str);
    void release();
    char *_str;
    int _count;
};

String.cpp

String::String(const char* str )
{
    if (NULL == str)
    {
        _str = new char[1];
        *_str = '\0';
    }
    else
    {
        _str = new char[strlen(str) + 1];
        strcpy(_str, str);
    }
    _count = 1;
}

String::String(String& s)
:_str(s._str)
, _count(++(s._count))
{
    strcpy(_str, s._str);
}

String::~String()
{
    if (--_count == 0 && NULL != _str)//_count是每个对象的，减去一个共享一块空间的其中一个对象的成员，并不会改变其他对象的成员变量_count的值
    {
        cout << this << endl;
        delete[] _str;
    }
}

所以，使用数据成员变量—–>pass

②使用静态数据成员：static int _count;
构造函数内：_count =1;
拷贝函数内部：_count++;
当出现情况：String s1;
String s2(s1);
String s3(s2);
这时的引用计数_count = 3;
但是当重新构造一个对象时：
String s4;——–>使得该类所有的引用计数_count = 1;

所以：静态数据成员也不可以。
下面详细讲解：

String.h

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;

class String
{
public:
    String(const char* str = "");
    String(String& s);
    String& operator=(const String& s);
    ~String();
private:
    int& GetRef(char *str);
    void release();
    char *_str;
    static int _count;
};

String.cpp

String::String(const char* str )
{
    if (NULL == str)
    {
        _str = new char[1];
        *_str = '\0';
    }
    else
    {
        _str = new char[strlen(str) + 1];
        strcpy(_str, str);
    }
    _count = 1;
}

String::String(String& s)
:_str(s._str)
{
    strcpy(_str, s._str);
    _count++;
}

String::~String()
{
    if (--_count == 0 && NULL != _str)
    {
        cout << this << endl;
        delete[] _str;
    }
}

int String:: _count = 0;

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

这里写图片描述

这里写图片描述

从上图可以看出静态成员变量是这个类所有的对象所共享的，所以当只是用一个对象去拷贝另一个对象时，这样不会出错，而且貌似也达到我们的要求了，可是当重新构造一个对象时，就会发现所有对象中的_count都修改为了1。

所以，使用静态成员(static int count)————>pass

③使用指针：
使得拷贝的对象共用指向一个引用计数。
这里写图片描述

赋值运算符重载函数中的两种情况：
第一种情况：
这里写图片描述

这里写图片描述

//String.h

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;

class String
{
public:
    String(const char* str = "");
    String(String& s);
    String& operator=(const String& s);
    ~String();
private:
    int& GetRef(char *str);
    void release();
    char *_str;
    int *_RefCount;
};

//String.cpp
#include"String-Ref.h"

String::String(const char* str )
{
    if (NULL == str)
    {
        _str = new char[1];
        *_str = '\0';
    }
    else
    {
        _str = new char[strlen(str) + 1];
        strcpy(_str, str);
    }

    _RefCount = new int(1);
}

String::String(String& s)
:_str(s._str)
,_RefCount(s._RefCount)
{
    strcpy(_str, s._str);
    (*_RefCount)++;
}

String::~String()
{
    if (--(*_RefCount) == 0 && NULL != _str)
    {
        cout << this << endl;
        delete[] _str;
        _str = NULL;
        delete _RefCount;
        _RefCount = NULL;
    }
}

String& String::operator=(String& s)
{
    if (this != &s)
    {
        if (--*_RefCount == 0)
        {
            delete[] _str;
            _str = NULL;
            delete _RefCount;
            _RefCount = NULL;
        }
        _str = s._str;
        _RefCount = s._RefCount;
        (*s._RefCount)++;
    }
    return *this;
}

void Test1()
{
    String s1("hello");
    String s2(s1);
    String s3(s2);
    String s4("world");
    s4 = s2;
}

这里写图片描述

这里写图片描述

由监视窗口的数据可得，使用指针可以完成引用计数的浅拷贝，但是因为每构造一个对象，都需要开辟两块空间，这样容易造成内存碎片。

由new[]可以联想到类似模型—->只开辟一块空间（多开四个字节），把引用计数放在字符串首地址的前四个字节上。
这样不但解决了内存碎片问题，而且也可以程序的运行效率。

引用计数的浅拷贝的最优解决方案：
(这里我就不一一分析了，思路和上面使用指针是一样的)

这里写图片描述

//String.h
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;

class String
{
public :
    String(const char* str = "");
    String(const String& s);
    String& operator=(const String& s);
    ~String();
private :
    int& GetRef(char *str);
    void release();
    char *_str;
};

//String.cpp

#include"string_simi.h"

String::String(const char* str)//构造函数
{
    if (NULL == str)
    {
        _str = new char[5];
        _str += 4;
        *_str = '\0';
    }
    else
    {
        _str = new char[strlen(str) + 5];
        _str += 4;
        strcpy(_str, str);
    }
    GetRef(_str) = 1;
}

String::String(const String& s)//拷贝构造函数
:_str(s._str)
{
    GetRef(_str)++;
}

//s1 = s2;
String& String::operator=(const String& s)//赋值运算符重载
{
    if (_str != s._str)//判断自赋值
    {
        //1.当s1的引用计数为1时
        //①释放空间
        //②改变s1指针的指向
        //③s2的引用计数加1
        release();
        //当s1的引用计数大于1时
        //①s1的引用计数减1
        //同上②③

        _str = s._str;
        GetRef(s._str)++;
    }
    return *this;
}

void String::release()
{
    if (--GetRef(_str) == 0)
    {
        delete[](_str - 4);
    }
}

int& String::GetRef(char *str)//获取引用计数
{
    return *(int*)(str - 4);
}

String::~String()//析构函数
{
    if (--GetRef(_str) == 0)
    {
        delete[] (_str - 4);
    }
}

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

int main()
{
    TestString1();
    return 0;

引用计数的浅拷贝同样存在缺陷—>当几个共用同一块空间的对象中的任一对象修改字符串中的值，则会导致所有共用这块空间的对象中的内容被破坏掉。

由此—->引入了写时拷贝（Copy On Write）
顾名思义，写时拷贝—>写的时候进行拷贝（深拷贝）


//String.h
#pragma once
#include<iostream>
using namespace std;
#include<assert.h>
class String
{
public:
     String(const char* str = "")//构造函数
     {
          if (NULL == str)
          {
              char* pTemp = new char[1 + 4];
              _pStr = pTemp + 4;
              _GetRefer() = 1;
              *_pStr = '\0';
          }
          else
          {
              char* pTemp = new char[strlen(str) + 1 + 4];
              _pStr = pTemp + 4;
              strcpy(_pStr, str);
              _GetRefer() = 1;
          }
     }

     String(const String& s)
          :_pStr(s._pStr)
     {
          _GetRefer()++;
     }
     ~String()
     {
          Release();
     }
     String& operator=(const String& s);
     char& operator[](size_t index);
     const char& operator[](size_t index)const;
     int& String::_GetRefer();
     void Release();
     friend ostream& operator<<(ostream& _cout, const String& s);
private:
     char* _pStr;
};

//String.cpp

#define _CRT_SECURE_NO_WARNINGS 1
#include"String3.h"

int& String::_GetRefer()//获取引用计数
{
     return *((int*)_pStr - 1);
}

void String::Release()//释放空间
{
     if (--_GetRefer() == 0)
     {
          _pStr -= 4;
          delete[] _pStr;
          _pStr = NULL;
     }
}

String& String::operator=(const String& s)
{
     if (_pStr != s._pStr)
     {
          if (--_GetRefer() == 0)//需要考虑两种情况
          {
              Release();
              _pStr = s._pStr;
              _GetRefer()++;
          }
          else
          {
              _pStr = s._pStr;
              _GetRefer()++;
          }

     }
     return *this;
}

char& String::operator[](size_t index)
{
     if (_GetRefer() > 1)
     {
          _GetRefer()--;
          char* pTemp = new char[strlen(_pStr) + 1 + 4];
          pTemp += 4;
          strcpy(pTemp, _pStr);
          _pStr = pTemp;
          _GetRefer() = 1;//新开的空间
     }
     return _pStr[index];
}

const char& String::operator[](size_t index)const
{
     return  _pStr[index];
}

void Test1()
{
     const String s1("hello");
     String s2(s1);
     //String s3;
     //s3 = s2;
     cout << s1[4] << endl;
}

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

[]重载运算符需要成对重载：

char& String::operator[](size_t index)
{
     if (_GetRefer() > 1)
     {
          char* pTemp = new char[strlen(_pStr) + 1 + 4];
          pTemp += 4;
          strcpy(pTemp, _pStr);
          _GetRefer()--;
          _pStr = pTemp;
          _GetRefer() = 1;//新开的空间
     }
     return _pStr[index];
}

const char& String::operator[](size_t index)const
{
     return  _pStr[index];
}
小葱1024
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++::浅拷贝，深拷贝，引用计数的拷贝，写时拷贝
海绵宝宝的欧尼~ 的博客
01-04 2737
【什么情况下会用到c++中的拷贝构造函数】：  1）用已经存在的同类的对象去构造出另一个新的对象   2）当函数的形参是类的对象时，这时调用此函数，使用的是值的拷贝，也会调用拷贝构造函数   3）当函数的返回值是类的对象时，这时当函数调用完后，会将函数的对象拷贝构造出一个临时的对象并传给函数的返回处 【浅拷贝】：(位拷贝（值拷贝）) 1、概念：所谓的浅拷贝就是当在进行对象的复制时
深浅拷贝及冷门小知识.rar
12-16
2. **引用计数**：Python内部维护了一个引用计数器，记录每个对象被引用的次数。当计数变为0时，对象将被销毁。 3. **循环引用**：两个或更多对象相互引用可能导致垃圾回收器无法正确工作。Python的垃圾回收器使用...
浅拷贝、深拷贝与引用计数
心飞扬
04-04 622
用模拟实现string来分析浅拷贝、深拷贝、引用计数。。。。。。。。
【内存】引用计数解决浅拷贝问题，利用写时复制解决改变值的问题
Edidaughter的博客
11-28 417
1.引用计数 引用计数是计算机编程语言中的一种内存管理技术，是指将资源（可以是对象、内存或磁盘空间等等）的被引用次数保存起来，当被引用次数变为零时就将其释放的过程。使用引用计数技术可以实现自动资源管理的目的。同时引用计数还可以指使用引用计数技术回收未使用资源的垃圾回收算法。 最直观的垃圾收集策略是引用计数。引用计数很简单，但是需要编译器的重要配合，并且增加了赋值函数(mutator) 的开销（这个术语是针对用户程序的，是从垃圾收集器的角度来看的）。每一个对象都有一个关联的引用计数 —— 对该对象的活跃.
深浅拷贝&引用计数写时拷贝
zjx624bjh的博客
10-29 253
深浅拷贝 引用计数 写时拷贝
引用计数——解决深拷贝浅拷贝的冲突
Anna的博客
02-19 322
下面是用代码实现： private: char *data; size_t use_count; public: //构造函数 String_rep(const char *str = ""):use_count(0) { if(str == NULL) { data = new char[1]; data[0] = '\0'; } else {
c++中深浅拷贝以及写时拷贝的实现示例代码
08-29
总结起来，C++中的深浅拷贝和写时拷贝都是关于如何正确地管理对象复制和内存的策略。深拷贝确保了每个对象都有独立的内存，而浅拷贝和写时拷贝则是在效率和数据一致性之间做出权衡。理解这些概念对于编写健壮和高效...
python闭包、深浅拷贝、垃圾回收、with语句知识点汇总
09-17
Python使用引用计数和周期性垃圾收集来实现这一过程。 **4. with语句** with语句用于处理资源的获取和释放，如打开文件、数据库连接等。它确保资源在使用完毕后会被正确地关闭，即使在执行过程中发生异常。with语句...
ios内存管理之深浅拷贝
03-21
本文将深入探讨iOS内存管理中的一个重要概念——深浅拷贝，以及与其相关的`retain`、`copy`和`retainCount`。这些概念对于理解Objective-C中的内存管理机制至关重要。 首先，我们需要了解iOS内存管理的基本原则，即...
大厂测试开发工程师面试资料——编程基础python
03-10
在 Python 中，引用计数是指每个对象都有一个引用计数，当对象的引用计数减少到 0 时，该对象将被释放。例如： ``` a = 10 # 创建一个对象，引用计数为 1 b = a # 引用计数增加到 2 del a # 引用计数减少到 1 ``` 在...
什么是浅拷贝，深拷贝，写时拷贝，引用计数
porryCn的博客
09-25 436
浅拷贝： &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 浅拷贝就是当类里面有指针成员时，进行赋值或者拷贝构造的时候，对数据成员逐一赋值，没有为指针成员分配新的内存，使得两个对象的指针成员指向同一块内存，这就是浅拷贝。由于两个对象指针指向了同一块内存，所以当析构的时候会出错。 深拷贝： &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 深拷贝就是当...
引用计数写时拷贝
adorable_的博客
04-19 379
引用计数   除初始化对象以外，每个构造函数（拷贝构造除外）需建立一个引用计数，用来记录多少对象与正在创建对象共享一块内存空间，当有新的指针指向这块空间时，引用计数加1。当创建一个对象且此对象未与其他对象共用一块内存空间时，将引用计数初始化为1。 拷贝构造不分配新的引用计数，而是拷贝计数器，并递增计数器。
深浅拷贝与引用计数
weeks
07-29 1146
其实本文重点想说一下引用计数，但是在说引用计数之前要说明一下深浅拷贝 深浅拷贝是对象调用拷贝构造函数的形式 当用一个已初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候，拷贝构造函数就会被自动调用。也就是说，当类的对象需要拷贝时，拷贝构造函数将会被调用。以下情况都会调用拷贝构造函数： （1）一个对象以值传递的方式传入函数体 （2）一个对象以值传递的方式从函数返回 （3）
拷贝带引用计数的对象时要注意的问题
weixin_33742618的博客
05-16 147
设Cobj是引用计数对象的基类。 class CmyObj:public Cobj{ public: 　　int m_a; 　　int m_b; 　　int m_c; 　　... }; 设现在有一个CmyObj类的对象myObjA，想对其进行复制，则下面方法是错误的： 法1：（错误方法） CmyObj*myObjB=new CmyObj(); myObjB-&gt;autor...
浅析深拷贝之写时拷贝&引用计数
SUST_YuXiao
11-07 420
形如百度网盘上传用户文件到服务器时，对于同一文件（如某软件安装包）服务器若将多个用户的同一文件独立存储，那么将浪费极大的存储空间。 正确的做法是: 在文件内容发生更改时进行深拷贝，在文件未发生变化时进行浅拷贝。 在文件内容剩最后一份需要析构时释放空间，否则不释放空间
linux 文件描述符 引用计数（close(fd)只是使fd的引用计数-1）
Dontla的博客
04-12 1740
在unix和linux平台需要考虑多进程的情况，fork时，子进程继承父进程所拥有的文件描述符，需要所有拥有者都close文件描述符才会把资源销毁，所以需要使用引用计数。 参考文章：linux socket close()函数将socket描述字引用计数-1是什么意思？ 后更。。。 ...
UNP学习笔记八：描述符引用计数
卡木
05-05 1069
（八）描述符引用计数当open()一个文件时有文件描述符；当socket()一个套接字时有套接字描述符；当accept()接收一个tcp连接时有已连接描述符。内核会对每个进程的所有描述符做记录，用一个描述符计数变量count，一个描述符count = 1。。。。。。，当count = 0时TCP才正常执行四路挥手终止。Exit()和close()都会使count – 1，但不会直接使TCP终止。尤...
文件描述符的文件操作(非缓冲)
君临
06-21 1027
文件描述符： 内核为每个进程维护一个已打开文件的记录表，文件描述符是一个较小的正整数（0—1023），它代表记录表的一项，通过文件描述符和一组基于文件描述符的文件操作函数，就可以实现对文件的读、写、创建、删除等操作。 1、打开,创建，关闭文件 open 和 creat 都能打开和创建函数，原型为 #include <sys/types.h> //头文件 #include <sys/stat.h> #include <fcntl.h> int open(const char
iOS开发--内存管理机制
过路的旅人^_^的博客
08-28 968
OC使用了一种叫做引用计数的机制来管理对象引用计数（reference counting）又称为保留计数（retaincounting），引用计数的数值表示有几个其它对象在使用它。retain（MRC）retain创建新对象（新对象引用计数+1），然后指向新对象。retain用法为先判断此新对象是否存在，如果存在先release，然后retain。如果不存在直接retain。一般用于指针对象，例如...
python 引用计数
最新发布
08-23
Python中的引用计数是一种内存管理技术，用于自动跟踪和回收不再使用的对象。每个对象都有一个引用计数，表示指向该对象的引用数量。当引用计数变为零时，对象不再被使用，可以被销毁并释放其占用的内存。 当对象被...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值