C++:String深拷贝

#include <iostream>
#include <cstdio>
#include <string.h>
#include <assert.h>
using namespace std;

#define TESTHEADER printf("\n================%s===============\n", __FUNCTION__)

////////////////////////////////////////////////////////////////////////////////////////
//String踏实版本
///////////////////////////////////////////////////////////////////////////////////////

// class String
// {
//     //s1("hello world!")
// public:
//     String(const char* str = "")
//         :_str(new char [strlen(str) + 1])
//         {
//             strcpy(this -> _str, str);
//         }
//     ~String()
//     {
//         if(_str != NULL)
//         {
//             delete[] _str;
//             _str = NULL;
//         }
//     }
//     //s1 = "hello world"
//     String operator = (const String& str)
//     {
//         if(this != &str)
//         {
//             char* tmp = new char[strlen(str._str) + 1];
//             strcpy(tmp, str._str);
//             this -> _str = tmp;
//         }
//         return *this;
//     }
//     char* c_str()
//     {
//         return this -> _str;
//     }
// private:
//     char* _str;
// };

////////////////////////////////////////////////////////////////////////////////////////
//String剥削版本
///////////////////////////////////////////////////////////////////////////////////////

// class String
// {
// public:
//     String(const char* str = "")
//         :_str(new char [strlen(str) + 1])
//         {
//             strcpy(this -> _str, str);
//         }
//     ~String()
//     {
//         if(_str != NULL)
//         {
//             delete[] _str;
//             _str = NULL;
//         }
//     }
//     String& operator = (const String& str)
//     {
//         if(this != &str)
//         {
//             String tmp(str._str);
//             swap(tmp._str, this -> _str);
//         }
//         return *this;
//     }
//     char* c_str()
//     {
//         return this -> _str;
//     }
// private:
//     char* _str;
// };

class String
{
public:
    String(const char* str = "")
        :_size(strlen(str))
        ,_capacity(_size)
        {
            _str = new char [_size + 1];
            strcpy(_str, str);
        }

    ~String()
    {
        if(_str != NULL)
        {
            delete[] _str;
            _str = NULL;
            _size = 0;
            _capacity = 0;
        }
    }

    void Swap(String& s)
    {
        swap(this -> _str, s._str);
        swap(this -> _size, s._size);
        swap(this -> _capacity, s._capacity);
    }

    String(const String& s)
        :_str(NULL)
    {
        String tmp(s._str);
        this -> Swap(tmp);
    }

    //s1 = s2
    //s1.operator(s1, s2)

    String& operator = (String& s)
    {
        s.Swap(*this);
        return *this;
    }

    char* c_str()
    {
        return _str;
    }

    size_t Size()
    {
        return _size;
    }

    void PushBack(char ch)
    {
        if(_size >= _capacity)
        {
            Expand(_capacity * 2);
        }
        _str[_size] = ch;
        ++ _size;
        _str[_size] = '\0';
    }

    size_t Capacity()
    {
        return _capacity;
    }

    bool Empty()
    {
        return _size == 0;
    }

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

    void Append(const char* str)
    {
        size_t len = strlen(str);
        if(_capacity > _size + len)
        {
            Expand(_capacity + len);
        }
        strcpy(_str + _size, str);
    }

    //s[0]
    //s.operator [] (s, 0)
    char& operator [] (size_t pos)
    {
        return _str[pos];
    }

    void Insert(size_t pos, char ch)
    {
        assert(pos <= _size);
        if(_size >= _capacity)
        {
            Expand(2 * _capacity);
        }
        int i = _size;
        while(i >= (int)pos)
        {
            _str[i + 1] = _str[i];
            i--;
        }
        _str[pos] = ch;
        ++ _size;
    }

    String& operator += (const char* str)
    {
        this -> Append(str);
        return *this;
    }

    String& operator += (const String& s)
    {
        *this += s._str;
        return *this;
    }

    String operator + (const char* str)
    {
        String ret(*this);
        ret += str;
        return ret;
    }

    String operator + (const String s)
    {
        String ret(*this);
        ret += s;
        return ret;
    }

    String& operator = (const String& s)
    {
        strcpy(this -> _str, s._str);
        this -> _size = s._size;
        this -> _capacity = s._capacity;
        return *this;
    }

    void Insert(size_t pos, const char* str)
    {
        assert(pos <= _size);
        size_t len = strlen(str);
        if(_size + len >= _capacity)
        {
            Expand(_size + len);
        }
        int end = _size;
        while(end >= (int)pos)
        {
            _str[end + len] = _str[end];
            --end;
        }
        strncpy(_str + pos, str, len);
    }

    void PopBack()
    {
        assert(_size > 0);
        _size--;
        _str[_size] = '\0';
    }


    void Erase(size_t pos, size_t len)
    {
        assert(pos < _size);
        if(pos + len > _size)
        {
            _size = pos;
            _str[pos] = '\0';
        }
        else
        {
           strcpy(_str + pos, _str + pos + len) ;
           _size -= len;
        }
    }

    void ReSize(size_t n, char ch = '\0')
    {
        if(n < _size)
        {
            _size = n;
            _str[_size] = '\0';
        }
        else
        {
            Expand(n);
            int i = _size;
            for(; i < (int)n; i++)
            {
                _str[i] = ch;
            }
            _str[i] = '\0';
            _size = n;
        }
    }

    void Reserve(size_t n)
    {
        Expand(n);
    }

    size_t Find(char ch)const
    {
        int i = 0;
        for(; i < (int)_size; i++)
        {
            if(ch == _str[i])
            {
                return i;
            }
        }
        return -1;
    }
    size_t Find(const char* sub)const
    {
        const char* src = _str;
        while(*src)
        {
            const char* dst = sub;
            const char* src_tmp = src;
            while(*dst && *dst == *src_tmp)
            {
                dst++;
                src_tmp++;
            }
            if(*dst == '\0')
            {
                return src - _str;
            }
            src++;
        }
        return -1;
    }
    bool operator < (const String& s)const
    {
        const char* p_str = _str;
        const char* p_s = s._str;
        while(*p_str && *p_s)
        {
            if(*p_str == *p_s)
            {
                p_str++;
                p_s++;
            }
            else if(*p_str < *p_str)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        //abc  abc1
        //abc  abc
        //abc  ab
        if(*p_str == '\0' && *p_s != '\0')
        {
            return true;
        }
        return false;
    }

    bool operator == (const String& s)const
    {
        char* src = s._str;
        char* dst = _str;
        while(*src && *dst)
        {
            if(*src == *dst)
            {
                src++;
                dst++;
            }
        }
        if(*src == '\0' && *dst == '\0')
        {
            return true;
        }
        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
    {
        return !(*this == s);
    }

private:
    char* _str;
    size_t _size;
    size_t _capacity;
};