Overloading += operator, unexpected result [duplicate] - c++

Question

This question already has answers here:
What is a dangling pointer?
(7 answers)
Is returning a reference to a local int variable always undefined behavior
(1 answer)
What are the basic rules and idioms for operator overloading?
(8 answers)
Why is the phrase: "undefined behavior means the compiler can do anything it wants" true?
(2 answers)
Closed last month.
I wrote my own string class for learning purposes. I'm trying to overload the += operator so that I can append strings together. But whenever I use the operator the inital object remains the same. I am confused.
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;
}
Here is the class header file:
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&);
};
I want to be able to create two strings and append with one another. But the it doesn't work. Any ideas? If possible, I'd want an explanation as to why this doesn't work so I can try to figure it out on my own, as I am trying to learn I don't want the solution handed to me. But I'll take whatever.
So here is what I'm trying to do.
StringF s("Hello");
StringF s2(", World!");
s += s2;
std::cout << s << std::endl; //Should print "Hello, World!" but only prints "Hello".
Thanks in advance!
Edit: Here is the example for you to try. https://onlinegdb.com/ApfkIONXG

Answer 1

There are a few issues with the code as posted:
There is a buffer overflow
You are not modifying the this instance like operator+= is supposed to
You are returning a reference to a local
Here is some minimally edited code that fixes these issues
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();
// +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;
}
We can modify the member variable because const char* is a mutable pointer to constant characters. This means the characters at the address of the pointer are constant, but the memory storing the pointer address is still mutable.
|string: 0xDEADBEEF| // The pointer value is not const
|
|----> |abc\0| // This data is const
see Const before or const after? for more info on the const issue.
The return *this is because the general expectation of operator+= is that the following code should work:
StringF s1("a");
StringF s2("b");
StringF s3 = (s += s2);
assert(s3 == s);
This might seem like non-sense code in this simple example, but this pattern is useful in some cases and is the expected behavior of a operator+= overload.