c++----模拟实现String类

传统写法是按部就班的走
现代写法是复用，调用其他函数实现

class String
{
public:
    //构造函数
    //String()
    //  :_str(new char[1])
    //{
    //  _str[0] = '\0';
    //}
    String(const char* str="")
        :_str(new char[strlen(str) + 1])
    {
        strcpy(_str, str);
    }
    //传统写法
    //String(const String& s)//拷贝构造,s3(s2)
    //  :_str(new char[strlen(s._str)+1])
    //{
    //  strcpy(_str,s._str);
    //}
    //String & operator=(const String& s)//s1=s2
    //{
    //  if (&s != this)
    //  {
    //      char* str = new char[strlen(s._str) + 1];
    //      delete[] _str;
    //      _str = str;
    //      strcpy(_str, s._str);
    //  }
    //  return *this;
    //}
    //现代写法
    String(const String& s)//拷贝构造,String s3(s2)
        :_str(NULL)
    {
        String tmp(s._str);
        swap(_str,tmp._str);
    }
    String & operator=(const String& s)//s1=s2,这块自己给自己赋值也是可以的，析构在最后，所以不会出错
    {
        if (&s != this)
        {
            String tmp(s._str);
            swap(tmp._str, _str);
        }
        return *this;
    }
    const char* c_str()//返回c形式的字符串
    {
        return _str;
    }
    ~String()//析构函数
    {
        if (_str)
            delete[] _str;
    }
private:
    char* _str;
};
void TestString()
{
    String s1;
    String s2("change world");
    cout << s2.c_str() << endl;
}

模拟实现string类

//现代写法的本质-复用
class String
{
public:
    String(const char* str = "")//构造函数
    {
        _size = _capacity = strlen(str);
        _str = new char[_capacity + 1];
        strcpy(_str, str);
    }
    //s1.Swap(s2)
    void Swap(String& s)
    {
        swap(_str, s._str);
        swap(_size, s._size);
        swap(_capacity, s._capacity);
    }
    String(const String& s)//拷贝构造,String s3(s2)
        :_str(NULL)
        , _size(0)
        , _capacity(0)
    {
        String tmp(s._str);
        Swap(tmp);
    }
    //s1=s2
    String & operator=(String s)//s1=s2,这块自己给自己赋值也是可以的，析构在最后，所以不会出错
    {
        Swap(s);
        return *this;
    }
    const char* c_str()const//返回c形式的字符串
    {
        return _str;
    }
    ~String()//析构函数
    {
        if (_str)
        {
            delete[] _str;
            _size = _capacity = 0;
            _str = NULL;
        }
    }
    void Expand(size_t n)//扩容
    {
        if (n > _capacity)
        {
            char* newstr = new char[n + 1];
            strcpy(newstr, _str);
            delete[] _str;
            _str = newstr;
            _capacity = n;
        }
    }
    void PushBack(char ch)
    {
        if (_size >= _capacity)
        {
            Expand(_capacity * 2);
        }
        _str[_size++] = ch;
        _str[_size] = '\0';
    }
    void PushBack(const char* str)
    {
        size_t len = strlen(str);
        if (_size + len > _capacity)
        {
            Expand(_size + len);
        }
        strcpy(_str + _size, str);
        _size += len;
    }
    void PopBack()
    {
        _str[_size] = '\0';
        _size--;
    }
    void PushFront(char ch)
    {
        Insert(0, ch);
    }
    void PushFront(const char* str)
    {
        Insert(0, str);
    }
    //void PopFront();
    void Insert(size_t pos, char ch)
    {
        assert(pos <= _size);
        if (_size >= _capacity)
        {
            Expand(_capacity * 2);
        }
        for (int i = _size; i >= pos; --i)
        {
            _str[i + 1] = _str[i];
        }
        _str[pos] = ch;
        _size++;
    }
    void Insert(size_t pos, const char* str)
    {
        assert(pos <= _size);
        const char* cur = str;
        size_t len = strlen(str);
        if (len + _size > _capacity)
            Expand(len + _size);
        for (int i = _size; i >= (int)pos; --i)
        {
            _str[i + len] = _str[i];
        }
        for (int i = 0; i < len; i++)
            _str[pos++] = str[i];
        _size += len;
    }
    void Erase(size_t pos, size_t n = 1)
    {
        if (n == 0)
        {
            return;
        }
        else if (pos + n >= _size)
        {
            _str[pos] = '\0';
            _size = pos;
        }
        else
        {
            strcpy(_str + pos, _str + pos + n);
            _size -= n;
        }
    }
    void Replace(char ch1, char ch2)//替换字符串中某个字符
    {
        char* str = _str;
        while (*str != '\0')
        {
            if (*str == ch1)
                *str = ch2;
            str++;
        }
    }
    size_t Find(char ch)
    {
        char* str = _str;
        while (*str != '\0')
        {
            if (*str == ch)
                return (int)(str - _str);
            str++;
        }
        return -1;
    }
    size_t Find(const char* str)
    {
        const char* str1 = _str;
        const char* str2 = str;
        while (*str1)
        {
            const char* cur = str1;
            const char* sub = str2;
            while (*str1 == *sub && sub!='\0')
            {
                ++cur;
                ++sub;
            }
            if (*sub == '\0')
            {
                return str1 - str;
            }
            else
            {
                sub = str;
                str1++;
            }
        }
        return -1;
    }
    //s1+'a'
    String operator+(char ch)
    {
        String tmp(*this);
        tmp.PushBack(ch);
        return tmp;
    }
    String& operator+=(char ch)
    {
        PushBack(ch);
        return *this;
    }
    String operator+(char* str)
    {
        String tmp(*this);
        tmp.PushBack(str);
        return tmp;
    }
    String& operator+=(char* str)
    {
        PushBack(str);
        return *this;
    }
    bool operator>(const String& s)const
    {
        const char* str1 = _str;
        const char* str2 = s._str;
        while (*str1&&*str2)
        {
            if (*str1 > *str2)
                return true;
            else if (*str1 < *str2)
                return false;
            else
            {
                ++str1;
                ++str2;
            }
        }
        if (*str1)
            return true;
        else
            return false;
    }
    bool operator>=(const String& s)const
    {
        return *this > s || *this == s;
    }
    bool operator<(const String& s)const
    {
        return !(*this >= s);
    }
    bool operator<=(const String& s)const
    {
        return !(*this>s);
    }
    bool operator==(const String& s)const
    {
        const char* str1 = _str;
        const char* str2 = s._str;
        while (*str1&&*str2)
        {
            if (*str1 != *str2)
                return false;
            else
            {
                ++str1;
                ++str2;
            }
        }
        if (*str1 == '\0'&&*str2 == '\0')
        {
            return false;
        }
        else
            return true;
    }
    bool operator!=(const String& s)const
    {
        return !(*this == s);
    }
    char& operator[](size_t pos)
    {
        return _str[pos];
    }
    const char& operator[](size_t pos)const
    {
        return _str[pos];
    }
private:
    char* _str;
    size_t _size;
    size_t _capacity;
};

如果有什么问题，可以评论告诉我，望指导！