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

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类的写时拷贝
写时拷贝：是在写的时候（即改变字符串的时候）才会真正的开辟空间拷贝（深拷贝），如果只是对数据的读时，只会对数据进行浅拷贝(只想读取文件时，深拷贝不管三七二十一 ，就直接给你开辟空间供str读)。

方案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的空间
（当有新指针指向这片空间时引用计数++，要释放空间时引用计数–，直到减为0时才真正释放这片空间 当有指针要改变这片空间是再为这个指针开辟一块新的空间让其进行操作，旧的空间count-1，新的空间count+1)

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;
};