c++中实现string类的问题

   每次在vs2013中的c++程序中实现string类时，在连接和拷贝函数时，以下用连接

举例。每次开辟好一段空间后，将this的字符串一个一个给到新空间，然后再把传的对象
的字符串一个一个连到新空间后面时，总会出现该问题
而我的代码是这样写的：

 String& operator+=(const String& s)
    {
        int length1 = strlen(_pStr);
        int length2 = strlen(s._pStr);
        char* p = s._pStr;
        char* tmp = new char[length1 + length2 + 1];
        while (*_pStr)
        {
            *tmp = *_pStr;
            tmp++, _pStr++;
        }
        _pStr = tmp;
        while (*p)
        {
            *_pStr = *p;
            _pStr++, p++;
        }
        *_pStr = '\0';
        return *this;
    }

String& operator+=(const String& s)
{
    int length1 = strlen(_pStr);
    int length2 = strlen(s._pStr);
    char* p = s._pStr;
    char* tmp = new char[length1 + length2 + 1];
    memcpy(tmp, _pStr, length1 + 1);

    for (size_t i = 0; i <= length2; i++)
    {
        tmp[length1++] = s._pStr[i];
    }
    _pStr = tmp;

    return *this;
}
char* Get_ptr()
{
    return _pStr;
}


我是这样改的 你看一下 创建空间后 应对它进行赋值

可以的话把代码贴全点来看看

 string s;
    s.append("1232423");
    int nLen = strlen(s.c_str());

int length1 = strlen(_pStr); 这个获取的长度是否正确哪？？？

因为Copy函数暂时没写出来，我就用了strcpy，但本意是不想用的。

 #define _CRT_SECURE_NO_WARNINGS

#include <iostream>
using namespace std;

class String
{
public:
    String(const char* pStr = "")
    {
        _pStr = new char[strlen(pStr) + 1];
        strcpy(_pStr, pStr);
    }



    String(const String& s)
        :_pStr(new char[strlen(s._pStr) + 1])
    {
        strcpy(_pStr, s._pStr);
    }

    ~String()
    {
        if (this != NULL)
        {
            delete[] _pStr;
            _pStr = NULL;
        }
    }


    String& operator=(const String& s)
    {
        if (this != &s)
        {
            _pStr = new char[strlen(s._pStr) + 1];
            strcpy(_pStr, s._pStr);
        }
        return *this;
    }


    char& operator[](const int idx)
    {
        return _pStr[idx];
    }
    const char& operator[](const int idx)const
    {
        return _pStr[idx];
    }


    size_t Size()const
    {
        char* pTemp = _pStr;
        int count = 0;
        while (*pTemp)
        {
            count++;
            pTemp++;
        }
        return count;
    }

    size_t Lengh()const
    {
        char* pTemp = _pStr;
        int count = 0;
        while (*pTemp)
        {
            count++;
            pTemp++;
        }
        return count;
    }


    //////////////////////////////////////////////
    bool operator>(const String& s)
    {
        char* pTemp = _pStr;
        char* pCur = s._pStr;
        while (*pCur)
        {
            if ((*pTemp) > (*pTemp))
            {
                return true;
            }
            else if ((*pTemp) == (*pTemp))
            {
                pTemp++, pCur++;
            }
            else
                return false;
        }
        return false;
    }
    bool operator<(const String& s)
    {
        char* pTemp = _pStr;
        char* pCur = s._pStr;
        while (*pCur)
        {
            if ((*pTemp) < (*pTemp))
            {
                return true;
            }
            else if ((*pTemp) == (*pTemp))
            {
                pTemp++, pCur++;
            }
            else
                return false;
        }
        return false;
    }
    bool operator==(const String& s)
    {
        char* pTemp = s._pStr;
        while ((*_pStr) && (*pTemp))
        {
            if ((*_pStr) == (*pTemp))
            {
                _pStr++;
                pTemp++;
            }
            else
                return false;
        }
        return true;
    }
    bool operator!=(const String& s)
    {
        if (*this == s)
        {
            return false;
        }
        else
            return true;
    }
    ////////////////////////////////////////////
    void Copy(String& s)
    {
        if (this != &s)
        {
            s._pStr = new char[strlen(_pStr) + 1];
            strcpy(s._pStr, _pStr);
        }
    }

    bool strstr(const String& s)
    {
        char* pTemp = s._pStr;
        char* pCur = _pStr;
        while (*pCur)
        {
            while (*pCur == *pTemp)
            {
                pTemp++;
                pCur++;
                if (*pTemp == '\0')
                {
                    return true;
                }
            }
            pCur++;
        }
        return false;
    }



    String& operator+=(const String& s)
    {
        int length1 = strlen(_pStr);
        int length2 = strlen(s._pStr);
        char* p = s._pStr;
        char* tmp = new char[length1 + length2 + 1];
        while (*_pStr)
        {
            *tmp = *_pStr;
            tmp++, _pStr++;
        }
        _pStr = tmp;
        while (*p)
        {
            *_pStr = *p;
            _pStr++, p++;
        }
        *_pStr = '\0';
        return *this;
    }





    friend ostream& operator<<(iostream& os, String& s);




private:
    char* _pStr;
};


ostream& operator<<(iostream& os, String& s)
{
    os << s._pStr;
    return os;
}

int main()
{
    String s1("you  are good!");
    String s2(s1);
    String s3;
    String s4;
    s3 = s1;
    s3[0] = 'i';
    s3[1] = 'l';
    s3[2] = 'z';
    s3[3] = 'c';
    cout << "The size of str is " << s3.Lengh() << " bytes" << endl;
    cout << "The size of str is " << s3.Size() << " bytes" << endl;
    cout << "s1 > s3 is " << (s1 > s3) << endl;
    s2 == s1;
    s1.Copy(s4);
    s3.operator+=(s1);

    //string str("Test string");
    //cout << "The size of str is " << s1.size() << " bytes.\n";
    //cout << s1 << endl;
    //cout << s2 << endl;
    system("pause");
    return 0;
}

char* Get_ptr()
{
return _pStr;
}
这个函数只是为了验证打印而已 ，

1.初始化申请的空间；
2.你的tmp指针一直在动，而tmp的内容是随机的，不一定有结束符；
3.你的全局指针需要归位。
String& operator+=(const String& s)
{
int length1 = strlen(_pStr);
int length2 = strlen(s._pStr);
char* p = s._pStr;
char* tmp = new char[length1 + length2 + 1];
char* pFix = tmp;
memset(tmp,0,sizeof(char)*(length1 + length2 + 1));//初始化，养成良好的习惯
while (*_pStr)
{
*tmp = *_pStr;
tmp++, _pStr++;
}
_pStr = tmp;
while (*p)
{
*_pStr = *p;
_pStr++, p++;
}
*_pStr = '\0';
_pStr = pFix;//回归置位
return *this;
}