《回溯 C++98：string 核心机制拆解 —— 从拷贝策略到高效 swap》

namespace Lotso
{
    class string 
    {
    private:
        char* _str;
        size_t _size;
    public:
        // 构造函数：分配内存并初始化
        string(const char* str = "") : _size(strlen(str)) 
        {
            _str = new char[_size + 1];
            strcpy(_str, str);
        }
        // 未实现深拷贝，使用编译器默认的浅拷贝
        ~string() 
        { 
            delete[] _str; 
        } // 析构时释放内存
      };

    // 崩溃
    int main() 
    {
        string s1("hello");
        string s2 = s1; // 浅拷贝：s1._str 与 s2._str 指向同一块内存
        return 0;

        // 析构时：s2 先释放内存，s1 再释放已被释放的内存→两个释放同一块内存程序崩溃
    }
};

class String
{
public:
    String(const char* str = "")
    {
        // 构造String类对象时，如果传递nullptr指针，可以认为程序非
        if (nullptr == str)
        {
            assert(false);
            return;
        }
        _str = new char[strlen(str) + 1];
        strcpy(_str, str);
    }
    String(const String& s)
        : _str(new char[strlen(s._str) + 1])
    {
        strcpy(_str, s._str);
    }
    String& operator=(const String& s)
    {
        if (this != &s)
        {
            char* pStr = new char[strlen(s._str) + 1];
            strcpy(pStr, s._str);
            delete[] _str;
            _str = pStr;
        }
        return *this;
    }
    ~String()
    {
        if (_str)
        {
            delete[] _str;
            _str = nullptr;
        }
    }
private:
    char* _str;
};

class String
{
public:
    String(const char* str = "")
    {
        if (nullptr == str)
        {
            assert(false);
            return;
        }
        _str = new char[strlen(str) + 1];
        strcpy(_str, str);
    }
    String(const String& s)
        : _str(nullptr)
    {
        String strTmp(s._str);
        swap(_str, strTmp._str);
    }
    // 对比下和上面的赋值那个实现比较好？
    String& operator=(String s)
    {
        swap(_str, s._str);
        return *this;
    }
    /*
    String& operator=(const String& s)
    {
    if(this != &s)
    {
    String strTmp(s);
    swap(_str, strTmp._str);
    }
    return *this;
    }
    */
    ~String()
    {
        if (_str)
        {
            delete[] _str;
            _str = nullptr;
        }
    }
private:
    char* _str;
};

class String {
public:
    void swap(String& s) {
        // 交换核心成员，无数据拷贝
        std::swap(_str, s._str);
        std::swap(_size, s._size);
        std::swap(_capacity, s._capacity);
    }
private:
    char* _str;
    size_t _size;
    size_t _capacity;
};

template <class T>
void swap(T& a, T& b)
{
    T c(a);// 深拷贝 a 到临时对象（O(n)
    a = b; //深拷贝 b 到 a（O(n)）
    b = c;// 深拷贝临时对象到 b（O(n)）
}

inline void swap(string& a, string& b)
{
    //还是调的库里的
    a.swap(b);
}