关于运算符重载的问题。

Miros

我想写个String类

class        String
{
private:
        char        *m_sData;
        wchar_t *CovToWChar()
        {
                wchar_t        *ws = new wchar_t[Length() + 1];
                MultiByteToWideChar(CP_ACP, 0, m_sData, -1, ws, (int)Length());
                return ws;
        }
protected:
        void        SetData(const char *s)
        {
                if (m_sData)
                        delete [] m_sData;
                m_sData        = new char[strlen(s) + 1];
                memcpy(m_sData, s, strlen(s) + 1);
        }
        void        Cat(const char *s)
        {
                SetLength(Length() + strlen(s));
                strcat(m_sData, s);
        }
public:
        String()
        {
                m_sData = new char[1];
                Clear();
        }
        String(const char *s)
        {
                m_sData        = NULL;
                SetData(s);
        }
        String(const String &s)
        {
                m_sData = NULL;
                SetData(s.m_sData);
        }
        virtual ~String()
        {
                delete [] m_sData;
        }
        void        Clear()
        {
                if (m_sData)
                        m_sData[0]        = 0;
        }
        operator char*()
        {
                return m_sData;
        }
        String& operator = (const char *s)
        {
                SetData(s);
                return *this;
        }
        bool        operator == (const char *s)
        {
                return (strcmp(m_sData, s) == 0);
        }
        bool        operator        != (const char *s)
        {
                return (strcmp(m_sData, s) != 0);
        }
        inline        String operator + (const char *s)const
        {
                String str(m_sData);
                str.Cat(s);
                return str;
        }
        inline        String operator + (const String &s)const
        {
                String str(m_sData);
                str.Cat(s.m_sData);
                return str;//到了这里的时候str回被析构了！
        }
        char& operator [](const size_t Index)
        {
                return m_sData[Index];
        }
        size_t        Length()
        {
                return strlen(m_sData);
        }
        void        SetLength(const size_t len)
        {
                char *pm = m_sData;
                m_sData        = new char[len + 1];
                m_sData[0]        = 0;
                strcat(m_sData, pm);
                delete [] pm;
        }
};

使用时
String s1, s2, s3;
s1 = '123';
s2 = 'ABC';
s3 = s2 + s1;//这里就会报错

hide106

inline String operator + (const String &s)const
{
String str(m_sData);
str.Cat(s.m_sData);
return str;//到了这里的时候str回被析构了！
}

该函数返回值应该声明为String&类型，否则你在函数体内创建的局部变量str在return str的时候，编译器会为你申请一个临时变量temp,然后调用temp = str,然后释放掉str，所以你得str被析构了。再者，从重载+的行为意图来分析，显然你希望把传入的const String&连接到当前变量也就是*this上，而不是连接到一个局部变量上，所以你这个函数体写的也有些问题吧。正确的意图应该是连接到*this上之后，return *this，这样不会产生任何类数据拷贝和临时数据的创建与析构，同时由于返回值类型应是String&，因此还可以继续对返回值进行assign或者其他操作。

6spring

楼上的理解错了吧，又不是+=

我的这么写的，注意不是成员+，是友元+
friend CString operator + (const CString &rhs1,const CString &rhs2);

CString operator + (const CString &rhs1,const CString &rhs2)
{
        CString tempstr(rhs1);
        tempstr += rhs2;
        return tempstr;
}

拷贝构造函数
CString::CString(const CString &rhs):m_pchData(&CStringSys::s_NullStr),m_pData(NULL)
{
        if(rhs.m_pData!=NULL)
        {
                m_pData = rhs.m_pData;
                m_pData->AddRef();

                m_pchData = m_pData->GetBuf();
        }
        else
                m_pData = NULL;
}