DZ小明
2017-02-22 09:52
采纳率: 75%
浏览 1.4k

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;
    }
  • 写回答
  • 关注问题
  • 收藏
  • 邀请回答

6条回答 默认 最新

  • BabysBreath_hl 2017-02-22 11:55
    已采纳
    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;
    }
    
    
    我是这样改的 你看一下 创建空间后 应对它进行赋值
    
    已采纳该答案
    打赏 评论
  • 仅仅学会简单 2017-02-22 10:00

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

    打赏 评论
  • shen_wei 2017-02-22 10:01
     string s;
        s.append("1232423");
        int nLen = strlen(s.c_str());
    

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

    打赏 评论
  • DZ小明 2017-02-22 10:23

    因为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;
    }
    
    打赏 评论
  • BabysBreath_hl 2017-02-22 11:57

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

    打赏 评论
  • 存在当代 2017-02-22 15:25

    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;
    }

    打赏 评论

相关推荐 更多相似问题