MyString：string类的模拟实现

前言：

为了区分标准库中的string，避免编译冲突，使用命名空间 MyString。

namespace MyString
{
    class string
    {
     private:
        char* _str;
        size_t _size;
        size_t _capacity;
        
        const static size_t npos = -1;// C++标准库支持的特殊用法
    };

以下都在 MyString 内实现！

一、构造函数，析构函数，拷贝构造

1.1 构造函数

标准库中，构造string类的常见写法：

string s1; // 1
string s2("hello world"); // 2

public:
	string()
        :_str(new char[1])// 给一个字节的空间作为标识
        ,_size(0)
        ,_capacity(0)
    {
        _str[_size] = '\0';
    }
    
    string(const char* str)
    {
        _size = strlen(str);
        _capacity = _size;
        _str = new char[_capacity + 1];// 多给一个空间，存'\0'
        strcpy(_str, str);
    }

实际上，对第二个构造函数的参数进行缺省，可以实现两种写法的完美统一。

    string(const char* str = "") // 字符串末尾有隐藏的'\0'，不需要我们在缺省值加上'\0'
    {
        _size = strlen(str);
        _capacity = _size;
        _str = new char[_capacity + 1];
        strcpy(_str, str);
    }

1.2 析构函数

public:
	~string()
    {
        delete[] _str;
        _str = nullptr;
        _size = _capacity = 0;
	}

1.3 拷贝构造(重点)

string类的拷贝构造需要实现深拷贝，否则会造成资源的二次释放。

public:
	string(const string& s)
    {
        _str = new char[s._capacity + 1];
        strcpy(_str, s._str);
        _size = s._size;
        _capacity = s._capacity;
	}

二、迭代器

public:
	typedef char* iterator;
	typedf const char* const_iterator;

	iterator begin()
    {
        return _str;
	}
	iterator end()
    {
        return _str + _size;
	}
	const_iterator begin() const
    {
        return _str;
	}
	const_iterator end() const
    {
        return _str + _size;
	}

范围for 本质是对迭代器的“傻瓜式”替换，一旦对 begin() end() 的函数名做修改，则无法调用，如：begin() ——> Begin() 。

三、reserve() 与 尾插（重点）

3.1 reserve()

【1】 reserve() 是对 _capacity 进行操作 （不对 _str 操作)，而 _capacity 只计算有效字符个数，不包括字符串末尾的 ‘\0’ 。

【2】 在设计 reserve() 时，要考虑多开一个空间，用于存 ‘\0’ ；要对 _capacity 校正。

【3】 在使用 reserve() 进行扩容时，只需要考虑 有效字符个数 即可。

public:
	void reserve(size_t n)
    {
        if (n > _capacity)
        {
            char* tmp = new char[n + 1];// 
            strcpy(tmp, _str);
            delete[] _str;
            _str = tmp;
            _capacity = n;
		}
    }

• n > _capacity 时，才需要调整
• char* tmp = new char[n + 1] 多开一个空间，用于存 ‘\0’ 。

3.2 尾插一个字符：push_back()

public:
	void push_back(const char ch)
    {
        if (_size == _capacity)
        {
            size_t newCapacity = _capacity == 0 ? 4 : 2 * _capacity;
            reserve(newCapacity);
            // _capacity = newCapacity;
            // reserve中 已经对 _capacity 做过调整了
		}
        _str[_size] = ch;
        ++_size;
        _str[_size] = '\0';
	}

• 插入字符后，应在字符串末尾加上 ‘\0’ ，否则通过 _str 访问字符串元素时会出现异常。

3.3 尾插字符串：append()

public:
	void append(const char* str)
    {
        int len = strlen(str);
        if (_size + len > _capacity)
        {
            reserve(_size + len);
            // reserve(_size + len + 1); // reserve中 已考虑在字符串末尾加上'\0'
		}
        strcpy(_str + _size, str);// str 末尾有隐藏的 '\0'
        _size += len;
	}

• str 末尾有隐藏的 ‘\0’

3.4 += 重载

• s1 += “x”;

public:
	string& operator+=(const char ch)
    {
        push_back(ch);
        return *this;
	}

• s1 += “xxxx”;

public:
	string& operator+=(const char* str)
    {
        append(str);
        return *this;
    }