C++基础 String类的实现（完整版）

String类

class String
{
public:
    String(const char *str="")//构造函数
        :_str(new char[strlen(str)+])
    {
        _size=strlen(str);
        _capy=_size;
        strcpy(_str,str);
    }
    void Swap(String &s)//交换函数，因为交换的不是一个值，需要自己构建交换函数
    {
        std::swap(_str,s._str);
        std::swap(_size,s._size);
        std::swap(_capy,s._capy);
    }
    String(const String &s)//拷贝构造
        :_str(NULL)
        ,_size()
        ,_capy()
    {
            String tmp(s._str);
            Swap(tmp);
    }
    ~String()//析构函数
    {
        delete[]_str;
    }

    String &operator=(String s)//赋值运算符
    {
        if (*this!=s)
        {
            String tmp(s);//应用了现代写法 交换  深拷贝
            Swap(tmp);
        }
        return *this;
    }

    void Expand(size_t n)//扩容
    {
        if (n>=_capy)
        {
            _capy=n;
        }
    }
    const char *c_str()//输出函数
    {
        return _str;
    }
    void Insert(size_t pos,char ch)//插入一个字符函数
    {
        if (_size>=_capy)//判断是否扩容
        {
            Expand(_capy*);
        }
        for (int i=_size;i>=pos;i--)
        {
            _str[i+]=_str[i];
        }
        _str[pos]=ch;
        _size++;
    }
    void Insert(size_t pos,const char* str)//插入一个字符串函数
    {
        int len=strlen(str);
        while (_size+len>=_capy)//用while不用if 防止一次扩容后还比_size小
        {
            Expand(_capy*);
        }
        for (int i=_size;i>=pos;i--)
        {
            _str[i+len]=_str[i];
        }
        for (int i=;i<len;i++)
        {
            _str[pos++]=str[i];
        }
        _size+=len;
    }
    void PushBack(char ch) 
    {
        Insert(_size,ch);
    }
    void PushBack(const char* str)
    {
        Insert(_size,str);
    }
    void Erase(size_t pos,size_t n=)//删除
    {
        if (n==)
        {
            return;
        }
        if (pos+n>_size)
        {
            _str[pos]='\0';
            _size=pos;
        }
        else
        {
            for (int i=pos+n;i<=_size;i++)
            {
                _str[i-n]=_str[i];
            }
            _size-=n;
        }
    }
    void Popback()
    {
        Erase(_size-,);
    }
    size_t Find(const char *str)//查找
    {
        const char*cur=str;
        const char *tmp=_str;
        while (*tmp)
        {
            const char*dev=tmp;
            while (*dev==*cur)
            {
                ++dev;
                ++cur;
            }
            if (*cur=='\0')
            {
                return tmp-_str;
            }
            else
            {
                cur=str;
                ++tmp;
            }
        }
        return -;
    }
    bool operator==(const String& s)
    {
        if (_size==s._size)
        {
            for (int i=;i<_size;i++)
            {
                if (_str[i]!=s._str[i])
                {
                    return false;
                }
            }
            return true;
        }
        return false;
    }
    bool operator>(const String& s)
    {
        const char *cur=_str;
        const char *tmp=s._str;
        while (*tmp&&*cur)
        {
            if (*cur>*tmp)
            {
                return true;
            }
            else if (*cur<*tmp)
            {
                return false;
            } 
            else
            {
                ++cur;
                ++tmp;
            }
        }
        if (*cur!='\0')
        {
            return true;
        }
        else
            return false;

    }
    bool operator>=(const String& s)
    {
        return *this>s||*this==s;
    }
    bool operator<(const String& s)
    {
        return ~(*this>=s);
    }
    bool operator<=(const String& s)
    {
        return ~(*this>s);
    }
    bool operator!=(const String& s)
    {
        return ~(*this==s);
    }
    String operator+(char ch) 
    {
        String tmp(*this);
        PushBack(ch);
        return tmp;
    }
    String& operator+=(char ch) 
    {
        PushBack(ch);
        return *this;
    }

    String operator+(const char* str)
    {
        String tmp(*this);
        PushBack(str);
        return tmp;
    }

    String& operator+=(const char* str) 
    {

        PushBack(str);
        return *     this;
    }
private:
    char *_str;//字符串
    size_t _size;//字符串的大小
    size_t _capy;//容量
};