C++深拷贝与浅拷贝（实现String类）

最新推荐文章于 2024-07-25 08:00:00 发布
最新推荐文章于 2024-07-25 08:00:00 发布
阅读量567 收藏 2
点赞数 1
分类专栏： 毕业生-必看系列 文章标签： 内存泄露 对象 c++ 函数 string
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dai_wen/article/details/78490265
版权

浅拷贝：

1.什么是浅拷贝？ 浅拷贝会出现什么问题？

所谓浅拷贝，指的是在对象复制时，只是对对象中的数据成员进行简单的复制，默认拷贝构造函数执行的也是浅拷贝。简单的说，浅拷贝就是值传递，将源空间里面的内容复制到目标空间中。

存在缺陷：多个指针可能共用管理一块内存空间，在释放时，导致对一块空间的多次释放，造成内存泄露。

深拷贝：

2. 什么是深拷贝？

在“深拷贝”的情况下，对于对象中动态成员，就不能仅仅简单地赋值了，而应该重新动态分配空间。

深拷贝与浅拷贝：

3.浅拷贝与深拷贝的不同之处：

用深动形象的语言来说，如果把拷贝看作下面这幅图，那么，浅拷贝只能拷走美人鱼的头，水下部分它将无法操作，而深拷贝 不仅可以拷走头，还可以操作水下隐含的部分。
图一

好了，说到这里，咱们可能对深浅拷贝或多或少的有了一些认识，那么，下面，我们将实现一个String 类，来更加具体权威的解释深浅构造函数。

4.完成String类-普通版（浅拷贝）

#include<iostream>
using namespace std;
class String
{
    public :
      String(const char*pStr="")//构造函数
        {
          if(NULL==pStr)
            {
                _pStr=new char[1];
                *_pStr='\0';
                }
        else 
        {
             _pStr=new char[strlen(pStr)+1];
             strcpy(_pStr,pStr);
        }
            }
    String(const String& s)//拷贝构造函数
            :_pStr(s._pStr)
        {    
            //s2已经释放，但s1不知道，会对空间再次释放
            } 
    String& operator=(const String& s)//赋值运算符重载
    {
        if(this!=&s)
        {
            _pStr=s._pStr;//内存泄露
        }
    return *this;
    }
~String ()//析构函数
{
  if(_pStr)
   {
      delete[] _pStr;
        _pStr=NULL;         
     }
}
private: 
    char* _pStr;

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

int main ()
{
    FunTest();
    /*String s1("hello");
    String s2(s1);
    String s3(NULL);
    String s4(s1);
    s3=s4;
    s3=s1;*/
    return 0;
}
该例证明了浅拷贝会存在多个对象共用同一块空间，在调用析构函数销毁空间时，会出现对一块空间多次释放的情况，导致内存崩溃

5. 完成String类深拷贝—简洁版

#include<iostream>
using namespace std;
class String
{
public :
//构造函数************************************************
    String(const char*pStr="")  
    {
        if(NULL==pStr)
        {
            _pStr=new char[1];
            *_pStr='\0';
        }
        else 
        {
            _pStr=new char[strlen(pStr)+1];
             strcpy(_pStr,pStr);
        }
            }
//拷贝构造函数********************************************
    String(const String& s)
        :_pStr(NULL)//选择最佳
        {
            //_pStr=new char[1];//第二选择
            String strTemp(s._pStr );
            swap(_pStr,strTemp._pStr);
            } 
//赋值 运算符重载******************************************
//方式一：
    String& operator=(const String& s)
    {
        if(this!=&s)
        {
            String strTemp(s._pStr);
            //String strTemp(s) ;
            swap(_pStr,strTemp._pStr) ;
        }
    return *this;
    }
//方式二：
//String& operator=(const String& s)
//  {
//      String strTemp(s) ;
//      swap(_pStr,strTemp._pStr) ;
//return *this;
//}
    //方式三：
    //String& operator=( String s)
    //{
    //  swap(_pStr,s._pStr );
    //  return *this;
    //}
//三种赋值运算符重载解决方案， 第一种方式为最优方案
//析构函数*****************************************
~String ()
{
  if(_pStr)
   {
      delete[] _pStr;
        _pStr=NULL;         
  }
}
private: 
    char* _pStr;
    int _count;
};

void  FunTest()
{
    String s1("Hello");
    String s2(s1);
    s2=s1;
}
int main ()
{
    FunTest();
    /*String s1("hello");
    String s2(s1);
    String s3(NULL);
    String s4(s1);
    s3=s4;
    s3=s1;*/
    return 0;
}

6.引用计数：

A.什么是引用计数?
在开辟空间时，为了记录该空间有多少对象在共用它，也就是说有多少指针指向它，采用再开辟一个空间的方式，记录该空间被指向的次数，这种方式被称为引用计数。
图二
B.用引用计数实现String时，引用计数可以普通的成员变量？为什么？
解析：引用计数不可以为普通的成员变量，因为一旦出了作用域，该空间被销毁，达不到想要的效果

C.用引用计数实现String时，引用计数可以类的静态成员变量吗？ 为什么？
解析：类的静态成员变量，但在需要另外开辟空间时，采用这种方式就

#include<iostream>
using namespace std;
class String
{
public :
    //构造函数
    String(const char* pStr="")
    {
        if(NULL==pStr)
        {
            _pStr=new char[1];
            *_pStr='\0';
        }
        else 
        {
            _pStr=new char[strlen(pStr)+1];
             strcpy(_pStr,pStr);
             }
    _count=1;
    }
String (const String& s)
    :_pStr(s._pStr)

   {
       _count++;
      }

~String ()
{
    if(_pStr&&(0==--*_count))
    {
        delete[] _pStr;
        _pStr=NULL;
    }
}
private: 
    char* _pStr;
    static int _count;
    };

int String::  _count=0;
void FunTest()
{
    String s1("hello");
    String s2(s1);

    String s3;
}

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

为了在释放的时候，防止忘记释放引用计数所开辟的空间，所以尽量采用new [ ]
的方式来开辟空间，与delete[ ]搭配使用。

7.完成引用计数版本的String类—该引用计数也属于浅拷贝

    //************引用计数*******************************
#include<iostream>
using namespace std;
class String
{
public :
    //构造函数
    String(const char* pStr="")
        :_pCount(new int (1))
    {
        if(NULL==pStr)
        {
            _pStr=new char[1];
            *_pStr='\0';
        }
        else 
        {
            _pStr=new char[strlen(pStr)+1];
             strcpy(_pStr,pStr);
        }
    }
String (const String& s)
    :_pStr(s._pStr)
    ,_pCount(s._pCount)

   {
       ++(*_pCount);
      }

String& operator=(const String& s)
{
    if(_pStr!=s._pStr)//被赋值的对象与当前对象不是同一块空间
    {
        if(_pStr&&0==--*_pCount)
        {
            delete [] _pStr;
            delete _pCount;
        }
        _pStr =s._pStr;
        _pCount=s._pCount;
        ++_pCount;
    }
    return *this;
}
~String ()
{
    if(_pStr&&(0==--*_pCount))
    {
        delete[] _pStr;
        _pStr=NULL;
        delete _pCount;
        _pCount=NULL;
    }
}
private: 
    char* _pStr;
     int* _pCount;
};
void FunTest()
{
    String s1("hello");
    String s2(s1);
    String s3;
}
int main()
{
    FunTest();
    return 0;
}

7. 完成COW(写时拷贝版的String)

（COW不是奶牛） 

//****写时拷贝：如果要朝当前对象写东西，最好使用这种方式*********
//单线程不会有问题
#include<iostream>
using namespace std;
class String
{
public :
    //构造函数
    String(const char* pStr="")
    {
        if(NULL==pStr)
        {
            _pStr=new char[1+4];
            _pStr+=4;
            *_pStr='\0';
        }
        else 
        {
            _pStr=new char[strlen(pStr)+1+4];
            _pStr+=4;
             strcpy(_pStr,pStr);
        }
        GetRaf()=1;
    }
String (const String& s)
    :_pStr(s._pStr)


   {
       GetRaf()++;
      }

String& operator=(const String& s)
{
    if(_pStr!=s._pStr)//被赋值的对象与当前对象不是同一块空间
    {
        Release();
        _pStr =s._pStr;
        ++GetRaf();
    }

    return *this;
}

~String ()
{
    Release();
}

char& operator [] (size_t index)
{
    if(GetRaf()>1)//如果当前空间不止存放的一个对象
    {
        char* pTemp=new char [strlen(_pStr)+1+4];
        *(int*)pTemp=1;
        pTemp+=4;
        strcpy(pTemp,_pStr);
        --GetRaf();//一定是在改变指针指向之前
        _pStr=pTemp;
    }
        return _pStr[index];
}
const char& operator [](size_t index)const 
{
    return _pStr[index];
}
private:
    int& GetRaf()
    {
            return *((int*)_pStr-1);
    }
    void Release()
    {
        if(_pStr&&(0==--GetRaf()))
            {
            _pStr-=4;
            delete[] _pStr;
            _pStr=NULL;
            }

    }
private: 
    char* _pStr;
};

void FunTest()
{
    String s1("hello");
    String s2(s1);
    s2[0]='w';
}

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

下面，在这里提出两点关于string类来说非常重要点：
一.熟悉库中string类的每个接口，查文档，熟悉库中的string类。
二.调研vs和linux系统下string类的结构，他们是否采用用深拷贝原理实现。

长颈鹿仙女
关注
专栏目录
【C++经典面试题】字符串类String的接口代码实现（重点考察对浅拷贝与深拷贝的理解）
dvlinker的技术专栏
07-26 38
【C++经典面试题】字符串类String的接口代码实现，重点考察对浅拷贝与深拷贝的理解。
C++深拷贝和浅拷贝
qq_33287871的博客
08-14 184
深拷贝和浅拷贝 1 浅拷贝 同一类型的对象之间可以赋值，使得两个对象的成员变量的值相同，两个对象仍然是独立的两个对象，这种情况被称为浅拷贝. 一般情况下，浅拷贝没有任何副作用，但是当类中有指针，并且指针指向动态分配的内存空间，析构函数做了动态内存释放的处理，会导致内存问题。 2 深拷贝 当类中有指针，并且此指针有动态分配空间，析构函数做了释放处理，往往需要自定义拷贝构造函数，自行给指针动态分配空间，深拷贝。 class Person{ public: Person(char* name,
详解C++中String类模拟实现以及深拷贝浅拷贝
12-31
详解C++中String类模拟实现以及深拷贝浅拷贝 在C语言中/C++中，字符串是一个应用很广泛的类型，也是很基础的类型，C语言并没有直接处理字符串的操作而是采用字符指针和字符串数组进行操作，而在C++中标准库为我们封装了一个字符串的类供我们使用，使用需要#inlcude <string>头文件。我们也可以自己模拟实现一个简单的String类。 在模拟实现String类的过程中，不可避免的会遇到深拷贝浅拷贝的问题，下面就深拷贝浅拷贝做一个简介。所谓深拷贝浅拷贝，简单来说就是浅拷贝只是简单的将值拷贝过来，用一个对象初始化另一个对象，只复制了成员，并没有复制资源，使两个对象同时指向了同一资源的。
C++:String深拷贝
qq_41027326的博客
07-16 960
#include &lt;iostream&gt; #include &lt;cstdio&gt; #include &lt;string.h&gt; #include &lt;assert.h&gt; using namespace std; #define TESTHEADER printf("\n================%s===============\n", __FUNCTIO...
[C++] string管理：深浅拷贝&写时拷贝
最新发布
Kevin ’ s blog
07-25 1220
写实拷贝，深拷贝，浅拷贝深度讲解
【C++】简易版的String类与深拷贝
码农印象
04-03 247
前言什么是深拷贝？深拷贝的内存分析普通版本的深拷贝 什么是深拷贝？ 深拷贝不同于浅拷贝，它在拷贝的时候会为新对象开辟一块新的内存空间，然后将原对象的内容拷贝到新开辟的空间，这样在资源释放的时候就不会牵扯到多次析构·的问题。比如构造了S1与S2两个对象，在构造S2时拷贝一块跟S1指向数据库一样大的数据块，并将值拷贝下来，这样S1与S2指向各自的数据块，析构时也自然释放自己的数据块。 源代码及注释（...
C++实现String类的深浅拷贝
痴心不改的博客
08-03 312
浅拷贝：也称位拷贝，编译器只是直接将指针的值拷贝过来，当多个对象共用同一块内存，当一 个对象将这块内存释放掉之后，另一些对象不知道该块空间已经还给了系统，以为还有效，所以 在对这段内存进行操作的时候，发生了访问违规。 代码实现浅拷贝： 引用计数—-普通版 /*给引用计数也创建一个内存空间，并且和共享内存一样，让引用计数也共享*/ class String { public: ...
C++中String类模拟实现以及深拷贝浅拷贝
xy913741894的博客
10-22 1318
在C语言中/C++中，字符串是一个应用很广泛的类型，也是很基础的类型，C语言并没有直接处理字符串的操作而是采用字符指针和字符串数组进行操作，而在C++中标准库为我们封装了一个字符串的类供我们使用，使用需要#inlcude 头文件。我们也可以自己模拟实现一个简单的String类。 在模拟实现String类的过程中，不可避免的会遇到深拷贝浅拷贝的问题，下面就深拷贝浅拷贝做一个简介。所谓深拷贝浅拷贝，
深究C++深拷贝/浅拷贝
IamCerian的博客
04-15 1432
目录1、什么是深\浅拷贝2、 何时要用到拷贝3、哪里要注意深浅拷贝4、为什么要注意深浅拷贝5、如何避免这个问题 1、什么是深\浅拷贝 假设现在有一片源内存空间，和一个待分配引用的目标对象内存空间，目的是给目标对象空间分配内存。而定义简而言之，深拷贝会复制源内存空间并重新生成一片内存空间，并将其引用给目标对象，而浅拷贝则正好相反，是直接将源内存空间引用给目标对象内存空间。 2、 何时要用到拷贝 C+...
C++ string类深浅拷贝问题详解
小白的Coding之旅
09-23 503
主要内容 string类的常用接口（最常用的接口） string类对象的常见构造 函数名称 功能说明 string() （重点） 构造空的string类对象，即空字符串 string(const char* s) （重点） 用C-string来构造string类对象 string(size_t n, char c) string类对象中包含n个字符c string(co...
c++string的深拷贝
热门推荐
zhang1308299607的博客
07-10 1万+
在c++中当我们想要去拷贝一个字符串的时候就会存在两种方式： 1 浅拷贝方式                   2深拷贝方式 浅拷贝： 所谓的浅拷贝就是让当前的指针指向一块已存在的区域，和其他指针共享同一块地址空间 浅拷贝所带来的问题是当程序结束的时候，对象d1和d2都会去调用析构函数清零这个快空间，而一块空间析构两次可能就会导致程序崩溃。（这里暂不考虑写时拷贝） 深拷
C++ 类的深拷贝
05-22
设计并实现一个动态整型数组类Vect，要求： （1）实现构造函数重载，可以根据指定的元素个数动态创建初始值为0的整型数组，或根据指定的内置整型数组动态创建整型数组。 （2）设计拷贝构造函数和析构函数，注意使用深拷贝。 （3）设计存取指定位置的数组元素的公有成员函数，并进行下标越界，若越界则输出“out of boundary”。 （4）设计获取数组元素个数的公有成员函数。 （5）设计用于输出数组元素的公有成员函数，元素之间以空格分隔，最后以换行符结束。 在main函数中按以下顺序操作： （1）根据内置的静态整型数组{1,2,3,4,5}构造数组对象v1，根据输入的整型数构造数组对象v2。 （2）调用Vect的成员函数依次输出v1和v2的所有元素。 （3）输入指定的下标及对应的整型数，设置数组对象v1的指定元素。 （4）根据数组对象v1拷贝构造数组对象v3。 （5）调用Vect的成员函数依次输出v1和v3的所有元素。 设计并实现一个动态整型数组类Vect，要求： （1）实现构造函数重载，可以根据指定的元素个数动态创建初始值为0的整型数组，或根据指定的内置整型数组动态创建整型数组。 （2）设计拷贝构造函数和析构函数，注意使用深拷贝。 （3）设计存取指定位置的数组元素的公有成员函数，并进行下标越界，若越界则输出“out of boundary”。 （4）设计获取数组元素个数的公有成员函数。 （5）设计用于输出数组元素的公有成员函数，元素之间以空格分隔，最后以换行符结束。 在main函数中按以下顺序操作： （1）根据内置的静态整型数组{1,2,3,4,5}构造数组对象v1，根据输入的整型数构造数组对象v2。 （2）调用Vect的成员函数依次输出v1和v2的所有元素。 （3）输入指定的下标及对应的整型数，设置数组对象v1的指定元素。 （4）根据数组对象v1拷贝构造数组对象v3。 （5）调用Vect的成员函数依次输出v1和v3的所有元素。
【C++】浅拷贝和深拷贝（String类）
皓皓松的博客
10-19 8098
浅拷贝 class String { public: String(const char *pStr = "") { if(NULL == pStr) { pstr = new char[1]; *pstr = '\0'; } else { pstr = new char[strlen(pStr)+1];//加1,某位是'\0' strcpy(ps
C++——浅拷贝
dashen2259的博客
01-08 151
10、深拷贝与浅拷贝 浅拷贝：实现对象间数据元素的一一对应赋值；（默认构造函数） 深拷贝：当被复制的对象数据成员是指针类型时，不是复制该指针成员本身，而是将指针所指的对象进行复制。 //浅拷贝 #include<iostream> using namespace std; class Point { public: Point() ...
c++ string类深拷贝
ChenMiao0924的博客
03-30 744
class String { public: String(char* pStr="") { if(pStr==NULL) { _pStr=new char[0];//为了统一使用delete[]释放空间 _pStr='\0'; } else { _pStr=new char[strlen(pStr)+1];//先拷贝同样大的空间 strcpy(
【C++】c++String类浅拷贝、深拷贝
SuLiJuan66的专栏
10-03 2201
c++String类浅拷贝、深拷贝
C++中浅拷贝
王尚权 qq:2515162716
06-07 179
#include "pch.h" #include <iostream> #include<string.h> using namespace std; class MyString { public: char *buffer; public: MyString(const char * init) { buffer = NULL; cout <&l...
string类
D_4_Y_的博客
03-18 246
标准库中的string类 1.string类 string是表示字符串的字符串类 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作 string在底层实际是：basic_string模板类的别名 不能操作多字节或者变长字符的序列 2.string类的常用接口说明 string类对象的常见构造 string() /...
C++设计模式实现--原型模式
cabinriver的专栏
05-07 7507
一、概述：     用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。其中有一个词很重要，那就是拷贝。可以说，拷贝是原型模式的精髓所在。举个现实中的例子来介绍原型模式。找工作的时候，我们需要准备简历。假设没有打印设备，因此需手写简历，这些简历的内容都是一样的。这样有个缺陷，如果要修改简历中的某项，那么所有已写好的简历都要修改，工作量很大。随着科技的进步，出现了打印设备。我们只需手写
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值