按值传递实参到函数和函数返回临时变量的副本，函数的效率对执行性能来说至关重要
如果避免这样的复制操作，则执行时间可能会大大缩短。
class CMessage { private: char * m_pMessage; public: void showIt()const { cout << m_pMessage << endl; } //构造函数 CMessage(const char* text = "Default message") { cout << " 构造函数" << endl; size_t length{ strlen(text) + 1 }; m_pMessage = new char[length + 1]; strcpy_s(m_pMessage, length + 1, text); } //复制构造函数 CMessage(const CMessage & aMess) { cout << "复制构造函数" << endl; size_t len{ strlen(aMess.m_pMessage) + 1 }; this->m_pMessage = new char[len]; strcpy_s(m_pMessage, len, aMess.m_pMessage); } //重载赋值运算符 CMessage & operator=(const CMessage & aMess) { cout << "重载赋值运算符函数" << endl; if (this != &aMess) { delete[]m_pMessage; size_t length{ strlen(aMess.m_pMessage) + 1 }; m_pMessage = new char[length]; strcpy_s(this->m_pMessage, length, aMess.m_pMessage); } return *this; } CMessage operator+(const CMessage & aMess) { cout <<"重载加法运算符函数" << endl; size_t len{strlen(m_pMessage)+strlen(aMess.m_pMessage)+1}; CMessage message; message.m_pMessage = new char[len]; strcpy_s(message.m_pMessage,len,m_pMessage); strcat_s(message.m_pMessage,len,aMess.m_pMessage); return message; } //析构函数 ~CMessage() { cout << " 析构函数" << endl; delete[]m_pMessage; } }; int main() { CMessage motto1{ "Amiss is " }; CMessage motto2{"as good as a mile"}; CMessage motto3; motto3 = motto1 + motto2; motto3.showIt(); }
运行结果如下：
构造函数 //motto1调用
构造函数 //motto2调用
构造函数 //motto3调用
重载加法运算符函数
构造函数 //operator+()中message对象调用
复制构造函数 //返回时对message对象的复制，生成message的临时副本
析构函数 //message调用，销毁临时对象
重载赋值运算符函数 //motto3调用operator=()
析构函数 //message的临时副本调用
Amiss is as good as a mile
析构函数
析构函数
析构函数
----------------------------------------------------------------------------------------------------------------------------------------------------------------
改进方法：应用rvalue引用形参
当源对象是一个临时对象，在复制操之后立即就被销毁时，复制的替代方案是偷用由 m_pMessage 成员指向的临时对象的内存，并传送到目标对象。
如果这么做，那么不需要为目标对象分配更多的内存，不需要复制对象，也不需要释放源对象拥有的内存。
在操作完成以后将立即销毁源对象，因此这么做没有风险，只是加快了执行速度。
实现此技术的关键是检测复制操作中何时是一个 rvalue。
CMessage(const CMessage & aMess)
{
cout << "复制构造函数" << endl;
size_t len{ strlen(aMess.m_pMessage) + 1 };
this->m_pMessage = new char[len];
strcpy_s(m_pMessage, len, aMess.m_pMessage);
}
CMessage(CMessage && aMess)
{
cout << "" << endl;
m_pMessage = aMess.m_pMessage;
aMess.m_pMessage = nullptr; //必须要这么做，防止删除原指向的内存
}
我们知道用对象初始化当前对象、返回临时对象都会调用复制构造函数。
motto3 = motto1 + motto2;调用重载加法运算符函数后会产生临时变量 message。
而对临时变量的复制产生需要的临时副本会增加运行时间。
所以，临时变量的副本可以直接“偷用”源临时变量对象成员指向的内存。通过以上两个函数比较可知，lvalue引用形参多了复制的操作。
难道要 lvalue引用形参的形式没有用了吗？
若: motto3=motto1 时，可知必须用 lvalue 引用形参的形式。如果 rvalue 可用，将会使两个对象同时指向一块内存。
所以， rvalue 针对 临时变量。
可以像下面这样额外创建 operator=()函数的重载
CMessage & operator=(CMessage && aMess)
{
cout <<"Move assignment operator function called." << endl;
delete[]m_pMessage;
m_pMessage = aMess.m_pMessage;
aMess.m_pMessage = nullptr; //必须要这么做，防止删除原指向的内存
return *this;
}
CMessage & operator=(const CMessage & aMess)
{
cout << "重载赋值运算符函数" << endl;
if (this != &aMess)
{ delete[]m_pMessage;
size_t length{ strlen(aMess.m_pMessage) + 1 };
m_pMessage = new char[length];
strcpy_s(this->m_pMessage, length, aMess.m_pMessage);
}
return *this;
}
观察这两个 lvalue、rvalue引用形参重载赋值运算符函数的区别：
motto3 = motto1 + motto2;调用重载加法运算符函数后会产生临时变量 message。在函数返回时又调用 rvalue引用形参类型的复制构造函数，
产生临时对象 message 的临时副本。
之后调用重载赋值运算符函数，由于此时仍是临时对象的副本，
所以，仍可以采用“ 偷换 ”源临时变量对象成员指向的内存。而避免赋值函数对对象成员的复制。
临时对象由编译器生成，使用之后会自动调用析构函数释放。
所以此处需要我们通过观察代码运行，自己来理解。
CMessage operator+(const CMessage & aMess)
{
cout <<"重载加法运算符函数" << endl;
size_t len{strlen(m_pMessage)+strlen(aMess.m_pMessage)+1};
CMessage message;
message.m_pMessage = new char[len];
strcpy_s(message.m_pMessage,len,m_pMessage);
strcat_s(message.m_pMessage,len,aMess.m_pMessage);
return message;
}
不知道你有没想过哟，为什么上面函数没有返回引用，引用可以避免不必要的复制，不是很方便吗？
添加引用 CMessage & operator+(const CMessage & aMess)
运行结果：
构造函数
构造函数
构造函数
重载加法运算符函数
构造函数
析构函数
重载赋值运算符函数
请按任意键继续. . .
发现程序崩溃，运行到重载赋值运算符函数就不能继续运行了。
Why?
如果被返回的对象是被调用函数中的局部变量，则不应按引用方式返回它。
因为，在被调用函数执行完毕时，局部对象将调用其 析构函数。
如果函数返回一个没有公有复制构造函数的类（如 ostream 类）的对象，它必须返回指向对象的引用。
如果在类中定义了 operator=()成员函数和复制构造函数时，将形参定义为非常量 rvalue 引用，则需要确保也定义了具有 const lvalue引用形参的标准版本。
编译器会提供它们的默认版本，逐一成员的进行复制。