按值 C++ 返回时进行双倍移动

你好，为了学习 C++，我正在构建自己的字符串类，并且有一个关于按值返回的问题。

MTX::String MTX::String::operator+(String& sObject)
{
//Calculate the size of a buffer we will need
int _cBufferSizeTmp = (_cBufferSize - 1) + sObject._cBufferSize;
//Now create a buffer which can hold both of the objects
char* _cBufferTmp = new char[_cBufferSizeTmp];
//Now copy first string in to it, but without the terminator
Memory::Copy((void*)_cBuffer, _cBufferTmp, _cBufferSize - 1);
//Copy second string but with null terminator
//Now that takes into account the offset of a second string to copy (void *)(_cBufferTmp + (_cBufferSize - 1))
Memory::Copy((void*)sObject._cBuffer, (void *)(_cBufferTmp + (_cBufferSize - 1)), sObject._cBufferSize);
//And now we construct our tmp string with it
String _tmpString;
_tmpString._cBuffer = _cBufferTmp;
_tmpString._cBufferSize = _cBufferSizeTmp;
return _tmpString;
}

问题是，当值返回时，它通过 move 构造函数移动到临时对象，然后这个临时对象再次根据他的方案移动到另一个对象

int main() {

MTX::String Greetings;
MTX::String tst1 = "Hello World";
MTX::String tst2 = "! And good byen";

Greetings = tst1 + tst2;
std::cout << Greetings.sBuffer();  //Didnt implement ostream stuff yet
return 0;
}

所以这是控制台输出

Created an empty string object
Created a string object "Hello World"
Created a string object "! And good bye
"
Created an empty string object
Created (Move) a string object "Hello World! And good bye //Here it creates a new tmp object and moves previous tmp in to it
"
deleting a string object
moved a string object via =
deleting a string object
Hello World! And good bye
deleting a string object
deleting a string object
deleting a string object

为什么它先将其移动到另一个 tmp 对象中，然后再实际将其分配给问候对象。

这是字符串的完整源代码.cpp

#include "String.h"
#include "Memory.h"
//Work better on utils
int MTX::String::Length(const char *cBuffer) {
int count = 0;
while (cBuffer[count] != '') {
count++;
}
return count;
}
char* MTX::String::sBuffer()
{
return _cBuffer;
}
MTX::String& MTX::String::operator=(String& sObject) 
{
std::cout << "Copied a string bject via =n";
return (String&) Buffer<char>::operator=((String&) sObject);
}
MTX::String& MTX::String::operator=(String&& sObject) noexcept 
{
std::cout << "moved a string object via = n";
return (String&) Buffer<char>::operator=((String&&) sObject);
}
MTX::String& MTX::String::operator=(const char* cBuffer)
{
Clear();
//Get Length of a buffer with String::Length();
int cBufferSize = String::Length(cBuffer) + 1;
//Create a buffer
_cBuffer = new char[cBufferSize];
_cBufferSize = cBufferSize;
//Copy contents of a buffer to local buffer
Memory::Copy((void*)cBuffer, (void*)_cBuffer, _cBufferSize);
return *this;
}
MTX::String MTX::String::operator+(String& sObject)
{
//Calculate the size of a buffer we will need
int _cBufferSizeTmp = (_cBufferSize - 1) + sObject._cBufferSize;
//Now create a buffer which can hold both of the objects
char* _cBufferTmp = new char[_cBufferSizeTmp];
//Now copy first string in to it, but without the terminator
Memory::Copy((void*)_cBuffer, _cBufferTmp, _cBufferSize - 1);
//Copy second string but with null terminator
//Now that takes into account the offset of a second string to copy (void *)(_cBufferTmp + (_cBufferSize - 1))
Memory::Copy((void*)sObject._cBuffer, (void *)(_cBufferTmp + (_cBufferSize - 1)), sObject._cBufferSize);
//And now we construct our tmp string with it
String _tmpString;
_tmpString._cBuffer = _cBufferTmp;
_tmpString._cBufferSize = _cBufferSizeTmp;
return _tmpString;
}
MTX::String MTX::String::operator+(const char* pBuffer)
{
//Calculate the size of a buffer we will need
int _cBufferSizeTmp = (_cBufferSize - 1) + String::Length(pBuffer) + 1;
//Now create a buffer which can hold both of the objects
char* _cBufferTmp = new char[_cBufferSizeTmp];
//Now copy first string in to it, but without the terminator
Memory::Copy((void*)_cBuffer, _cBufferTmp, _cBufferSize - 1);
//Copy second string but with null terminator
//Now that takes into account the offset of a second string to copy (void *)(_cBufferTmp + (_cBufferSize - 1))
Memory::Copy((void*)pBuffer, (void*)(_cBufferTmp + (_cBufferSize - 1)), String::Length(pBuffer) +1);
//And now we construct our tmp string with it
String _tmpString;
_tmpString._cBuffer = _cBufferTmp;
_tmpString._cBufferSize = _cBufferSizeTmp;
//no need to delete the tmp buffer, cause ownership was taken away from it.
//And return it by value cause it is gona get deleted anyway
return _tmpString;
}
MTX::String MTX::String::operator<<(String& sObject) noexcept
{
return *this + sObject;
}
MTX::String MTX::operator<<(MTX::String sObjectSelf, MTX::String sObject) {
return sObjectSelf + sObject;
}

这是基类

//Constructor Default
Buffer() : _cBuffer(nullptr), _cBufferSize(0) {};
Buffer(T* pBuffer, int len) {

//Check if pBuffer is not nullptr
if (pBuffer != nullptr) {
//Allocate the memory needed for a buffer
_cBuffer = new T[len];
_cBufferSize = len;
//Now copy contents of a buffer 
Memory::Copy((void*)pBuffer, (void*)_cBuffer, sizeof(T) * len);
}
else {
_cBuffer = nullptr;
_cBufferSize = 0;
}
};
Buffer(Buffer& Object)
{
//If attempted to clone empty buffer
if (Object._cBuffer != nullptr) {
//Create new buffer with a size of a source buffer
_cBuffer = new T[Object._cBufferSize];
_cBufferSize = Object._cBufferSize;
//Copy contents of that buffer in to local
Memory::Copy((void*)Object._cBuffer, (void*)_cBuffer, _cBufferSize);
}
else {
_cBuffer = nullptr;
_cBufferSize = 0;
}
};
Buffer(Buffer&& Object) {
// If attempting to move empty buffer
if (Object._cBuffer != nullptr) {
//Take ownership of buffer
_cBuffer = Object._cBuffer;
Object._cBuffer = nullptr;
//Set buffer size
_cBufferSize = Object._cBufferSize;
Object._cBufferSize = 0;
}
else {
_cBuffer = nullptr;
_cBufferSize = 0;
}
};
Buffer& operator=(Buffer& Object) {
//Clear buffer, cause it is going to be cleaned anyway
Clear();
//If attempted to clone empty buffer
if (Object._cBuffer != nullptr) {
//Create new buffer with a size of a source buffer
_cBuffer = new T[Object._cBufferSize];
_cBufferSize = Object._cBufferSize;
//Copy contents of that buffer in to local
Memory::Copy((void*)Object._cBuffer, (void*)_cBuffer, _cBufferSize);
}
return *this;
};
Buffer& operator=(Buffer&& Object) {
//Same as copy assign, buffer is going to be cleared anyway
Clear();
// If attempting to move empty string
if (Object._cBuffer != nullptr) {
//Take ownership of buffer
_cBuffer = Object._cBuffer;
Object._cBuffer = nullptr;
//Set buffer size
_cBufferSize = Object._cBufferSize;
Object._cBufferSize = 0;
}
return *this;
};

和字符串构造函数

//Constructors
String() 
:Buffer() {
std::cout << "Created an empty string objectn";

};
String(const char* cBuffer)
:MTX::Buffer<char>((char*)cBuffer, String::Length(cBuffer) + 1) {

std::cout << "Created a string object"<<" ""<<cBuffer<<""n";

};
String(String& sObject)
:MTX::Buffer<char>((String&)sObject) {
std::cout << "Created (Copy) a string object" << " "" << sObject._cBuffer << ""n";

};
String(String&& sObject) noexcept
:Buffer<char>((String&&)sObject) {

std::cout << "Created (Move) a string object" << " "" << _cBuffer << ""n";
};
~String() {


std::cout << "deleting a string objectn";


}