“操作员+=”行为异常的定义

Question

简介

我正在定义我自己的 String 类。除了我打算用来连接Strings 的+= 的定义之外，一切都很好

//expected behaviour
String c = "foo";
String d = "lala";

c+=d;
cout<<c;

应该输出：

foolala

我遇到了一个问题，因为它似乎确实可以正常工作，除了最后一位似乎没有传递指针。

这是代码（我省略了大部分其他定义，因为我认为它们对此没有用处）

---

代码

class String{

    private:
        unsigned int SizeS;
        char *Buffer;

    public:
        String():SizeS(0){}

        String(unsigned int i):SizeS(i){Buffer=new char[SizeS];}

        String(const char *string)
        {
            //defines the initialiser
            SizeS = strlen(string);                 //find out the length of the string
            Buffer = new char[SizeS];               //allocate space for the entire string+1 for terminator
            memcpy(Buffer,string,SizeS);            //copy to buffer the whole thing
            Buffer[SizeS]=0;                        //terminate the buffer with an end character
        }

        char * GetBuffer() const { return this->Buffer; }

        String (const String& copied) :SizeS(copied.SizeS)
        {
            // defines how copying  works
            Buffer = new char[SizeS];
            memcpy(Buffer,copied.Buffer,SizeS);
        }


        // this is where the issue is ------------------
        String* operator += (const String& to_concat)
        {
            unsigned int newSize = this->SizeS + to_concat.SizeS;
            String *p = new String(newSize) ;
            memcpy(p->Buffer,this->Buffer,this->SizeS);
            memcpy(p->Buffer+this->SizeS,to_concat.Buffer,to_concat.SizeS);

            std::cout<<p->Buffer<<std::endl;

            return p;
        }
        // this is where the issue ends ------------------
};

std::ostream&  operator<< (std::ostream& stream, const String& other) { stream << other.GetBuffer(); return stream; }


int main()
{
    String c="foo";
    std::cout<<c<<std::endl;
    c += c;
    std::cout<<c<<std::endl;
}

预期输出

foo
foofoo
foofoo

实际输出

foo 
foofoo
foo

---

问题

我做错了什么？据我了解，我用指针p 覆盖了指针c，但似乎c 没有改变。这是为什么呢？

---

解决方案

在阅读了 cmets 和建议后，我想出了这个可行的解决方案。

        String& operator += (const String& to_concat)
        {
            unsigned int newSize = this->SizeS + to_concat.SizeS;
            char* p = new char[newSize];

            memcpy(p,this->Buffer,this->SizeS);
            memcpy(p+this->SizeS,to_concat.Buffer,to_concat.SizeS);

            delete[](this->Buffer);

            this->Buffer=p;
            this->SizeS=newSize;

            return *this;
        }

Answer 1

因为你没有写任何代码来改变c。

没有“指针c”，即使有，你也不会覆盖它。

您的 += 使用原始两个字符串中的数据创建一个新的、动态分配的字符串，然后返回一个指向它的指针，然后您的程序将其丢弃（顺便说一下，泄漏了该新字符串）。

您应该修改this 中的缓冲区，而不是创建和返回p（然后，按照惯例，将*this 作为String& 返回以允许链接）。

此外，+= 运算符不应产生输出。

---

+ 操作符的工作方式与您的操作方式类似，因为它们应该生成新对象，但您实际上不应该为此使用 new — 您仍然会有内存泄漏.尽量避免动态分配（尽管您将需要动态分配每个String 的buffer 指针指向的缓冲区）。