有关深浅丶写时拷贝的那点事

1.所谓浅拷贝，就是由默认的拷贝构造函数实现的数据成员逐一赋值。通常默认的拷贝构造函数是能够胜任此工作的，但若是类中含有指针类型的数据，这种按数据成员逐一赋值的方法将会产生错误。
有关浅拷贝的例子：

class sudent
{
public:
  student(char*name1,float scdre1);
  ~student();
private:
  char *name;
  float score;
};
student(char* name1,float score1)
{
 cout<<"xingming"<<name1<<endl;
 name=new char[strlen(name1)+1];
  if(name!=0)
  {
   strcpy(name,name1);
   score=score1;
  }
}
~student()
{
  cout<<destruct...<<name<<endl;
  name[0]='\0';
  delete[]name;
}
int main()
{
  student s1("zhangsan",90);//定义类student的对象s1。调用默认的拷贝构造函数
  student s2=s1;
  return 0;
}

这里写图片描述
运行程序后发现程序错误，这是因为主程序结束时对象逐个被撤销，先撤销s2，第一次调用析构函数用delete释放动态分配的内存空间，撤销s1时第二次调用析构函数，此时指针name所指的空间已被释放，执行delete[]name时，企图释放同一空间，导致同一空间的两次释放，这是不被允许的。
2.为了解决浅拷贝出现的错误，必须显示的定义一个自定义的拷贝构造函数，使之不但复制数据成员，而且为对象s1和s2分配各自内存空间，这就是所谓的深拷贝。

  student(student & stu)  
   {
    name=new char[strlen(stu.name)+1];
    if(name!=0)
     {
     strcpy(name,name1);
     score=score1;
     }
   }

这里写图片描述
构造s2时拷贝一块跟s1指向数据块一样大的数据块，并将值拷贝下来，这样s1和s2指向各自的数据块，析构时释放各自的数据块。
3.string类的写时拷贝
写时拷贝：是在写的时候（即改变字符串的时候）才会真正的开辟空间拷贝（深拷贝），如果只是对数据的读时，只会对数据进行浅拷贝。
方案1：我们为每个内存的字符数组添加一个引用计数count,即就是在构造函数申请空间的时候多申请出来4个字节。表示有多少个对象使用这块内存，有多少个对象使用，就让count值加1，当对象被析构的时候，让count值减1，当count值为0的时候，将这块内存释放掉。当然count也要实现内存共享，所以它也是一个堆中的数据，每个对象都有一个指向它的指针。

#include <iostream>
using namespace std;

class String
{
public:
    String(char* str = "")//构造
        :_str(new char[strlen(str)]+1)
        , _refCount(new int(1))
    {
        strcpy(_str, str);
    }
   String(const String& str)//拷贝构造----浅拷贝 
        : _str(str._str)
        ,_refCount(str._refCount)
    {
        (*_refCount)++;
    }

    ~String()//析构
    {
        if(--(*refCount)==0)
      {
       delete[]  _str;
       delete _refCount;
      }
    }
    String& operator = (const String& s)//赋值运算符重载
{
      if(_str != s._str)//判断是否为自己给自己赋值
      {
           if(--(*_refCount)==0)
          {
            delete[] _str;
            delete _refCount;
          }
          _str = s._str;
          _refCount = s._refCount;
          (*refCount)++;
      }
      return *this;
}
private:
    char* _str;
    int* _refCount;
};

这里写图片描述

方案2：开辟一个空间，前面4个字节为计数器count，剩下的为字符串_str的空间

class String
{
public:
    String(const char* str="")//构造
        :_str(new char[strlen(str)+1+4])
    { 
        _str+=4;//走到数据区首地址
        strcpy(_str,str);
        GetCount()=1;//计数器区域赋值为1
    }

    String(const String& s)//拷贝构造
        :_str(s._str)
    {  
        ++GetCount();//将所指向的共同内存的计数器加+
    }

    String& operator=(String& s)//赋值运算符重载---赋值的对象计数器要++;被赋值的对象计数器要++
    {
        if (this!=&s)
        {

            if (--GetCount()==0)
            {
                delete[] (_str-4);//回到内存的首位置
            }
            ++(s.GetCount());
            _str=s._str;

        }
        return *this;
    }

    ~String()//析构
    {   
        if (--GetCount()==0)
        {
            cout<<"释放"<<endl;   
            delete[] (_str-4);
            _str=NULL;
        }
    }
       int& GetCount()
    {
        return *((int*)_str - 1);
    }

private:
    char* _str;
};

这里写图片描述

有关深浅丶写时拷贝的那点事

猜你喜欢