[C++]String类的理解

如果不主动编写拷贝构造函数和赋值函数,编译器将以“位拷贝”

的方式自动生成缺省的函数(浅拷贝)。倘若类中含有指针变量,那么这两个缺省的函数就隐含了错误。
以类 String 的两个对象 a,b 为例,假设 a.m_data 的内容为“hello”, b.m_data 的内容为“world”。现将a赋给b,缺省赋值函数的“位拷贝”意味着执行b.m_data= a.m_data。 这将造成三个错误:
1. b.m_data 原有的内存没被释放,造成内存泄露;
2. b.m_data 和 a.m_data 指向同一块内存,a 或 b 任何一方变动都会影响另一方;
3. 在对象被析构时,m_data 被释放了两次。
故需要深拷贝

下面是最容易理解的一种写法：

#define _CRT_SECURE_NO_WARNINGS#include<iostream>#include<string.h>using namespace std;class String{    friend ostream& operator<<(ostream &out,String &rhs);    friend istream& operator>>(istream &in,String &rhs);public:    String(char *str = "")        :_pstr(new char[strlen(str)+1])    {        strcpy(_pstr,str);    }    String(const String& s)        :_pstr(new char [strlen(s._pstr)+1])    {        strcpy(_pstr,s._pstr);    }    String& operator=(const String& other)    //1.检查自赋值    //2.用 delete 释放原有的内存资源    //3.分配新的内存资源,并复制字符串    //4.返回本对象的引用（连等）    {        if(this != &other)        {            delete []_pstr;            _pstr = new char [strlen(other._pstr)+1];            strcpy(_pstr,other._pstr);        }        return *this;    }    ~String()    {        if(_pstr != NULL)        delete []_pstr;    }    void Debug()    {        cout<<"string:> "<<_pstr<<endl;        cout<<"count:> "<<*_ref<<endl;    }private:    char *_pstr;};ostream& operator<<(ostream &out,String &rhs){    out<<rhs._pstr;    return out;}istream& operator>>(istream &in,String &rhs){    in>>rhs._pstr;    return in;}void Fun1(){    String A("aaaaa");    String B(A);    String C = B;    C = A;    cin>>C;    cout<<C<<endl;}

下面还有一种简洁的拷贝构造和赋值运算符重载函数：
理解图：

    String(const String& s)        :_pstr(NULL)//没有指向的指针不能交换里面的内容    {        String temp(s._pstr);        std::swap(temp._pstr,_pstr);    }    String& operator=(String rhs)//运算符重载隐含了左值，故不需要赋空    //此时没有将参数赋为const String& other的原因：    //将下面实现换成注释也可完成同样功能，但重复了上面的拷贝构造内容，如换成没有注释的形式，则增强代码重用率，在下面进行交换的时候可以重复调用拷贝构造函数，也可达到赋值的目的。    {        //String temp(s._pstr);        //std::swap(temp._pstr,_pstr);        std::swap(_pstr,rhs._pstr);        return *this;    }//返回值联等  参数会产生临时变量

然而深拷贝并不见的完全好，如果多个对象都存储了相同的内容，那岂不是很浪费空间，于是我们又发明了一个叫做引用计数的东西，就是把相同内容的对象只存储一遍，用一个计数器记下他的数目，每构造一次将其置一，每拷贝构造一次将其加一，每赋值一次将其加一（原来的引用计数减一），但如果将引用计数设为 int _ref 我们每次进行操作都会对其原来的引用计数加一（其实他原来的_ref并不需要改变，甚至在调用赋值重载时还会减一），而将其换为 static int _ref 时，如果我们申请了新的对象

比如：    String A;    String B(A);    String C;

C的出现会将前面A B的引用计数一同改变，所以这也不是什么好办发，然而最好的办法是将引用计数设为指针
int * _ref 这样实现起来解容易多了，也可像库函数STL实现一样将该引用计数放于私有成员字符串的前4个字节，节省了一个私有成员的开销，这种方法与库函数中的new类似，new ＝ 开辟空间(malloc)＋调用构造函数(定位new) new operator = 开辟空间。
下面是写时拷贝的实现：

class String{    friend ostream& operator<<(ostream &out,String &rhs);    friend istream& operator>>(istream &in,String &rhs);public:    String(char *str = "")        :_pstr(new char[strlen(str)+1])        ,_ref(new int[1])//申请一个4字节的空间  new int(1)    {        strcpy(_pstr,str);        _ref[0]=1;//里面存放计数    }    String(const String &s)        :_pstr(NULL)        ,_ref(NULL)    {        _pstr = s._pstr;        _ref = s._ref;        (*_ref)++;    }    String& operator=(const String &rhs)    {        if(rhs._pstr != this->_pstr)        {            if( --(*_ref) == 0)            {                delete []_pstr;                if(_ref != NULL)//_ref可能为空                    delete []_ref;            }            _pstr = rhs._pstr;            _ref = rhs._ref;            (*_ref)++;//_red[0]++        }        return *this;    }    ~String()    {        if(--(*_ref) == 0)        {            delete []_pstr;            if(_ref != NULL)                delete []_ref;        }    }    void Debug()    {        cout<<"string:> "<<_pstr<<endl;        cout<<"count:> "<<*_ref<<endl;    }private:    char *_pstr;    int *_ref;};ostream& operator<<(ostream &out,String &rhs){    out<<rhs._pstr;    return out;}istream& operator>>(istream &in,String &rhs){    in>>rhs._pstr;    return in;}void Fun2(){    String a("qqq");    a.Debug();    String b("dfhdfhd");    //a.Debug();    String c(b);    b.Debug();    c = a;    a.Debug();    b.Debug();    c.Debug();}