动手实现一个string类

参考
String类的浅拷贝、深拷贝、写时拷贝
C++面试中STRING类的一种正确写法

深拷贝的版本

赋值拷贝是重点：

1.是否将返回值声明为该类型的引用，并且在函数结束前返回实例自身的引用（即*this）。因为只有返回一个引用才可以进行连续赋值。

2.是否将传入参数声明为常量引用。如果传入参数不是引用，那么形参到实参会调用一次拷贝构造函数，引用可避免这样无谓消耗，提高代码效率。同时不能改变传入实例的状态，所以要将引用参数加上const关键字。

3.是否释放自己的内存。如果忘记在分配新内存之前释放自身已有的空间，程序将出现内存泄漏。

4.是否判断传入参数和当前实例（*this）是不是同一个实例。如果是同一个不进行赋值操作，直接返回。如果不实现判断就进行赋值，那么赋值前会释放自身空间，那么传入参数的内存也同时被释放，将再也找不到需要赋值的内容。推荐使用局部临时变量的方式实现异常安全。

//1.深拷贝的版本
#include<cstring>
#include<iostream>
using namespace std;

class String1{
public:
    //构造函数,这种带默认参数，既可以有无参构造的功能，又有有参构造的功能
    String1(const char* pStr=""){
        //传入nullptr,应该生成空串“”,只有'\0'字符
        if(pStr==nullptr){
            m_pStr=new char[1];
            m_pStr[1]='\0';
        }else{
            m_pStr=new char[strlen(pStr)+1];
            strcpy(m_pStr,pStr);
        }
    }
    //复制构造函数，注意参数必须为引用
    String1(const String1& rhs){
        m_pStr=new char[strlen(rhs.m_pStr)+1];
        strcpy(m_pStr,rhs.m_pStr);
    }
    //赋值运算符,得支持连续赋值，所以必须返回引用
    String1& operator=(const String1& rhs){
        //检查是否自我赋值
        if(this!=&rhs){
            //采用局部临时变量,避免人为释放原内存
            String1 strTemp(rhs);
            //交换指针
            char* pTemp=strTemp.m_pStr;
            strTemp.m_pStr=m_pStr;
            m_pStr=pTemp;

        }//离开这里时,旧空间自动释放

        return *this;
    }
    
   //ostream这个类型，往往出现在<<操作重载中，作为某个类的友元函数出现。
    friend ostream& operator << (ostream& os, const String1& rhs)
    {
        return os << rhs.m_pStr;
    }
    //析构函数
    ~String1(){
        if(m_pStr!=nullptr)
        {
            delete[] m_pStr;
            m_pStr=nullptr;
        }
    }


private:
    char* m_pStr=nullptr;
};

带移动语义的

移动构造函数和移动赋值构造函数
来自 我理解的右值引用、移动语义和完美转发

#include <iostream>
#include <cstring>
#include <vector>
using namespace std;

class MyString
{
public:
    static size_t CCtor; //统计调用拷贝构造函数的次数
    static size_t MCtor; //统计调用移动构造函数的次数
    static size_t CAsgn; //统计调用拷贝赋值函数的次数
    static size_t MAsgn; //统计调用移动赋值函数的次数

public:
    // 构造函数
   MyString(const char* cstr=0){
       if (cstr) {
          m_data = new char[strlen(cstr)+1];
          strcpy(m_data, cstr);
       }
       else {
          m_data = new char[1];
          *m_data = '\0';
       }
   }

   // 拷贝构造函数
   MyString(const MyString& str) {
       CCtor ++;
       m_data = new char[ strlen(str.m_data) + 1 ];
       strcpy(m_data, str.m_data);
   }
   // 移动构造函数
   MyString(MyString&& str) noexcept
       :m_data(str.m_data) {
       MCtor ++;
       str.m_data = nullptr; //不再指向之前的资源了
   }

   // 拷贝赋值函数 =号重载
   MyString& operator=(const MyString& str){
       CAsgn ++;
       if (this == &str) // 避免自我赋值!!
          return *this;

       delete[] m_data;
       m_data = new char[ strlen(str.m_data) + 1 ];
       strcpy(m_data, str.m_data);
       return *this;
   }

   // 移动赋值函数 =号重载
   MyString& operator=(MyString&& str) noexcept{
       MAsgn ++;
       if (this == &str) // 避免自我赋值!!
          return *this;

       delete[] m_data;
       m_data = str.m_data;
       str.m_data = nullptr; //不再指向之前的资源了
       return *this;
   }

   ~MyString() {
       delete[] m_data;
   }

   char* get_c_str() const { return m_data; }
private:
   char* m_data;
};
size_t MyString::CCtor = 0;
size_t MyString::MCtor = 0;
size_t MyString::CAsgn = 0;
size_t MyString::MAsgn = 0;
int main()
{
    vector<MyString> vecStr;
    vecStr.reserve(1000); //先分配好1000个空间
    for(int i=0;i<1000;i++){
        vecStr.push_back(MyString("hello"));
    }
    cout << "CCtor = " << MyString::CCtor << endl;
    cout << "MCtor = " << MyString::MCtor << endl;
    cout << "CAsgn = " << MyString::CAsgn << endl;
    cout << "MAsgn = " << MyString::MAsgn << endl;
}

/* 结果
CCtor = 0
MCtor = 1000
CAsgn = 0
MAsgn = 0
*/

写时拷贝+引用计数的版本

当我们需要写的时候才去新开辟内存空间。这种方法就是写时拷贝。这也是一种解决由于浅拷贝使多个对象共用一块内存地址，调用析构函数时导致一块内存被多次释放，导致程序奔溃的问题。

这种方法需要用到引用计数，下面的实现中：真实字符串内存空间（即m_pStr指向的内存）的前4个字节用于保存该字符串被引用的次数。

class String2{
public:
    //构造函数
    String2(const char* pStr=""){
        if(pStr==nullptr){
            m_pStr=new char[1+4];
            *((int*)m_pStr)=1;
            m_pStr=(char*)(((int*)m_pStr)+1);
            *m_pStr='\0';
        }else{
            m_pStr=new char[strlen(pStr)+1+4];
            *((int*)m_pStr)=1;
            m_pStr=(char*)(((int*)m_pStr)+1);
            strcpy(m_pStr,pStr);

        }
    }
    //复制构造函数
    String2(const String2& rhs){
        m_pStr=rhs.m_pStr;
        getCount()++;
    }
    //赋值运算符
    String2& operator=(const String2& rhs){
        //测试是否自我赋值
        if(this!=&rhs){
            //引用计数为1时,会引发旧的内存被释放
             release();
             m_pStr=rhs.m_pStr;
             //引用计数增1
             ++getCount();
        }
        return *this;
    }
    
    //返回char&表明是可修改的,写时复制
    char& operator[](size_t index){
        //引用计数大于1时要重新开辟内存空间
        if(getCount()>1){
            --getCount();
            char* temp=new char[strlen(m_pStr)+1+4];
            *((int*)(temp))=1;//引用计数初始为1
            temp=(char*)((int*)(temp)+1);//temp后移4字节
            strcpy(temp,m_pStr);//拷贝
            m_pStr=temp;
        }
        return m_pStr[index];

    }

    //不可修改,只读,不用写时复制
    const char& operator[](size_t index)const{
        return m_pStr[index];
    }

    //ostream这个类型，往往出现在<<操作重载中，作为某个类的友元函数出现。
    friend ostream& operator<<(ostream& output,const String2& s){
        //注意友元函数不能像成员函数那样直接访问成员变量
        //output<<m_pStr;//这是错误的
        //必须通过参数中的对象/对象引用/对象指针直接访问
        output<<s.m_pStr;
        return output;
    }

    //析构函数
    ~String2(){
        if(m_pStr!=NULL){
            release();
        }
    }

private:
    char* m_pStr;
    int& getCount(){
        //m_pStr前面4个字节存放被引用次数
        return *((int*)m_pStr-1);
    }
    void release(){
        if(m_pStr&&(0==--getCount())){
            //移到原始申请的内存头部,然后delete
            m_pStr=(char*)((int*)m_pStr-1);
            delete[] m_pStr;
        }
    }
};

int main()
{
    String2 s1("abcd");
    String2 s2(s1);
    //修改前
    cout<<"s1=" <<s1<<endl;
    cout<<"s2=" <<s2<<endl;
    //修改s2
    s2[0]='Z';
    //修改后
    cout<<"s1=" <<s1<<endl;
    cout<<"s2=" <<s2<<endl;
    system("pause");
    return 0;
}

• 这里还有一份完整点的string类的隐式共享写时拷贝的实现
  C++ string类的隐式共享写时拷贝的实现及设计要点