String类的简单实现

我们知道String类，如果调用编译器自己合成的拷贝构造，赋值运算符重载，会出现一块内存多个对象使用的问题，在释放对象的时候，一块内存就会多次释放，引起程序崩溃。如果不了解对该过程不了解的，请在博主C++栏中，看看————String类的深浅拷贝。
下面是String类的简单实现，不调用C库中字符串函数：

#include<iostream>
using namespace std;
#include<cassert>
class String
{
public:
    String(const char* str = "")  //构造函数
    {
        if (str == NULL)
        {
            _str = new char[1];
            _str = '\0';
        }
        else
        {
            _str = new char[mystrlen(str) + 1];
            mystrcpy(_str, str);
        }
    }
    String(const String& s)//拷贝构造
        :_str(NULL)
    {
        String tmp(s._str);
    std:swap(tmp._str, _str);
    }
    String& operator=(const String& s)//赋值运算符重载
    {
        if (&s != this)
        {
            if (_str)
                delete _str;
            _str = new char[strlen(s._str) + 1];
            strcpy(_str, s._str);
        }
        return *this;
    }
    ~String()//析构函数
    {
        if (_str != NULL)
        {
            delete _str;
            _str = NULL;
        }
    }
    size_t Size()const
    {
        return mystrlen(_str);
    }
    bool operator>(const String& s)
    {
        if (mystrcmp(_str, s._str) > 0)//调用自己的字符串比较函数
        {
            return true;
        }
        return false;
    }
    bool operator<(const String& s)
    {
        if (*this > s)
        {
            return false;
        }
        return true;
    }
    bool operator==(const String& s)
    {
        if (mystrcmp(_str, s._str) == 0)
        {
            return true;
        }
        return false;
    }
    bool operator!=(const String& s)
    {
        if (mystrcmp(_str, s._str) == 0)
        {
            return false;
        }
        return true;
    }
    String operator+(const String& s)//两个字符串之间的拼接
    {
        String tmp;
        tmp._str = new char[mystrlen(_str) + mystrlen(s._str)+1];
        char *p = NULL;
        p = tmp._str;
        int size = mystrlen(_str);
        while (size--)
        {
            p++;  //第二字符串开始拷贝进tmp的地址
        }
        strcpy(tmp._str, _str);
        strcpy(p, s._str);
        return tmp;
    }
    size_t StrStr(const String& s)  //是否是子串
    {
        if (mystrstr(_str, s._str) != NULL)
        {
            return 1;
        }
        return 0;
    }
private:
    char * mystrcpy(char *dst, const char *src)const   //字符串拷贝
    {
        char *start = dst;
        while (*dst++ = *src++)
        {}
        return start;

    }
    const char *mystrstr(const char* dest, const char* source)const//子字符串
    {
        assert((NULL != dest) && (NULL != source));
        const char* dst = dest;
        const char* src = source;
        while (*dest)
        {
            const char *tmp = dest;
            while (*tmp++ == *src++ && *tmp && *src)
            {}
            if (*src == '\0')
            {
                return dest;
            }
            src = source;
            dest++;
        }
        return NULL;
    }
    int mystrcmp(const char *dest, const char *source) //比较两个字符串的大小
    {
        assert((NULL != dest) && (NULL != source));
        while (*dest && *source &&(*dest == *source))
        {
            dest++;
            source++;
        }
        return *dest - *source;
    }
    int mystrlen(const char*src)const//字符串长度
    {
        int count = 0;
        while ('\0' != *src++)
        {
            count++;
        }
        return count;
    }
private:
    char* _str;
};

int main()
{
    String s1("sss");
    String s2("ass");
    String s3 = s1 + s2;
    String s4(s1);
    cout << s1.StrStr(s2) <<endl;
    if (s1 < s2)
    {
        cout << "sss" << endl;
    }
    else
    {
        cout << "ass" << endl;
    }
    return 0;
}

如有错误，望得到指正。一起进步。谢谢。