Pointer changes value after exiting constructor - c++

Question

For some reason, whenever it reassigns the string as a different const char*, it has an error. After it creates a new buffer on a string with a previous buffer, when it exists the constructor the buffer changes value for no reason. I am using heap memory, so it shouldn't be affected by scope.
#include <iostream>
class String {
private:
char* buffer;
unsigned int size;
public:
String(const char* string) {
size = strlen(string);
buffer = new char[size + 1];
memcpy(buffer, string, size + 1);
buffer[size] = 0;
}
String(const String& other) {
memcpy(this, new String(other.buffer), sizeof(String));
}
~String() {
delete buffer;
}
friend std::ostream& operator<<(std::ostream& stream, const String& str);
String operator+(const String& other) {
unsigned int nSize = this->size + other.size;
char* nBuffer = new char[nSize + 1];
memcpy(nBuffer, this->buffer, nSize + 1);
strcat(nBuffer, other.buffer);
nBuffer[nSize] = 0;
return String(nBuffer);
}
void operator+=(const String& other) {
unsigned int nSize = this->size + other.size;
char* nBuffer = new char[nSize + 1];
memcpy(nBuffer, this->buffer, nSize + 1);
strcat(nBuffer, other.buffer);
nBuffer[nSize] = 0;
this->~String();
memcpy(this, new String(nBuffer), sizeof(String));
}
};
std::ostream& operator<<(std::ostream& stream, const String& str) {
stream << str.buffer;
return stream;
}
int main() {
String test1 = "Hello";
test1 = "there";
std::cout << test1 << std::endl;
}

Answer 1

test1 = "there" is the same as test1 = String("there") because the string "there" has to be converted to a String. The default assignment operator works by assigning all the members on the right hand side to the members on the left hand side. It does a shallow copy of all the members, so your strings are not actually duplicated, but rather both buffer pointers in test1 and String("there") point to the same memory location that holds the string "there".
At the end of the assignment the String("there") object has to be destroyed, so it calls the destructor which deletes the memory that its buffer is pointing to. At the end of the main() method the same happens with test1, only when it gets there it finds that the memory has already been deleted, causing a runtime error.
When dealing with raw pointers as class members, in addition to making your own copy-constructor you also have to make your own copy-assignment operator to delete the already held memory and allocate new memory. A simply one may look like this:
String& operator=(String const& other) {
delete[] buffer;
buffer = new char[other.size + 1];
strcpy(buffer, other.buffer);
size = other.size;
return *this;
}
Now assigning into test1 will allocate an entirely seperate memory space to hold the string.