反载 +=运算符，意外结果[重复]

Question

我为学习目的写了我自己的字符串课。我正在尝试使 +=运算符超载，以便可以将字符串加在一起。但是，每当我使用操作员时，Inital对象都保持不变。我很困惑

StringF& StringF::operator+=(StringF& obj) {
    const char* string = this->getString();
    const char* stringToAppend = obj.getString();

    const int stringLength = this->length();
    const int stringToAppendLength = obj.length();

    char* appendedString = new char[stringLength + stringToAppendLength];
    appendedString[stringLength + stringToAppendLength] = '\0';


    for (int i = 0; i < stringLength; i++) {
        appendedString[i] = string[i];
    }

    for (int i = stringLength; i < stringLength + stringToAppendLength; i++) {
        appendedString[i] = stringToAppend[i - stringLength];
    }

    StringF appendedObj = StringF::StringF(appendedString);

    std::cout << "Appended obj: " << appendedObj.getString() << std::endl; //For debugging

    return appendedObj;
}

the Class Header文件：

class StringF {
    private:
        const char* string;
    public:
        StringF(const char*);
        int length();
        const char* copy();
        const char* getString();
        const char* reverse();
        int find(const char*);
        StringF& operator+=(StringF&);
        friend std::ostream& operator<<(std::ostream&, StringF&);
};

我希望能够创建两个字符串并彼此附加。但是它行不通。有什么想法吗？如果可能的话，我想解释为什么这不起作用，以便我可以自己弄清楚，因为我试图学习我不希望解决方案交给我。但是我会拿什么。

这就是我要做的。

StringF s("Hello");
StringF s2(", World!");
s += s2;
std::cout << s << std::endl; //Should print "Hello, World!" but only prints "Hello".

提前感谢！

Edit：这是您尝试的示例。

https：//onlinegdb.com/apfkionxg

code的代码有一些问题：

有一个缓冲区溢出

Answer 1

您不应该像

this

operator+=
1. 的实例来修改

StringF& StringF::operator+=(StringF& obj) {
    const char* stringToAppend = obj.getString();

    const int stringLength = this->length();
    const int stringToAppendLength = obj.length();

    // +1 for the null character we are appending
    char* appendedString = new char[stringLength + stringToAppendLength + 1];
    appendedString[stringLength + stringToAppendLength] = '\0';


    for (int i = 0; i < stringLength; i++) {
        appendedString[i] = string[i];
    }

    for (int i = stringLength; i < stringLength + stringToAppendLength; i++) {
        appendedString[i] = stringToAppend[i - stringLength];
    }

    // TODO: de-allocate the previous 'string' member variable

    // Now we need to update `this`. While we can't modify the data pointed
    // at by the existing member pointer, we can change the pointer to point
    // to the newly allocated data:
    string = appendedString;

    // operator+= should be returning a reference to `this`
    return *this;
}

2. 实例 您正在返回对local

   的引用
   

   这里是一些修复这些问题的最低编辑代码

const char*
我们可以修改成员变量，因为

|string: 0xDEADBEEF|           // The pointer value is not const
            |
            |----> |abc\0|     // This data is const

是恒定字符的可变指针。这意味着指针地址上的字符是恒定的，但是存储指针地址的内存仍然可变。

const请参见“ const t”和“ t const”，以及您应该使用哪一个？

有关

return *this

问题的更多信息。

operator+=

是因为对以下代码应该有效的一般期望：

StringF s1("a");
StringF s2("b");
StringF s3 = (s += s2);
assert(s3 == s);

在这个简单的示例中，这似乎是无义的代码，但是在某些情况下，这种模式是有用的，并且是

operator+=

超载的预期行为。