著作权新闻稿：需经译者容许，切勿转发！
C++为何要搞个提及岀来，特别是右值提及，觉得毁坏了句法的简约和章法，复本两个操作符不是较好吗？
无论是右值提及还是右值提及，下层的结构设计方法论是一样的，一句话归纳就是：如何化解说明器的难题，让模块和codice的传达更快捷高效率，同时保持标识符的简约典雅。C++的左右值提及的确让句法变繁杂了，但从工程建设应用领域的视角，标识符更简约高效率了。
上面我从C++词汇发展的视角来说明那个难题，并提出更快认知左右值提及的下层方法论，最后得出工程建设应用领域的实例，目地是让新手能精确地掌控C++提及科学知识，并加速应用领域到工程建设实践中。
C 说明器：值与操作符的传达
在 C 标识符的说明器中传达单纯类别的表达式是没什么难题的，如 int、float 的表达式，也就几个二进制，多复本数次都不会有太大的天然资源开支。但在工程建设应用领域上，他们的标识符充满著了销售业务相关的内部结构体的表达式，这些内部结构体可能很繁杂。
上面以绘图程式结构设计中的行列式演算为例，他们先实现两个单纯的行列式类别及基础建设的乘法表达式：
//行列式演算 V1.0: C fork版struct Matrix { float data[3][3];};Matrix add(Matrix ma, Matrix mb){ Matrix mr; for (int i=; i<3*3; i++) mr.data[i]= ma.data[i]+ mb.data[i]; return mr;}int main(){ Matrix a ={{{1,2,3},{4,5,6},{7,8,9}}}; Matrix b ={{{2,2,2},{3,3,3},{4,5,6}}}; Matrix c = add(a, b); return;}
在表述 Matrix 计算机程序时，为了精简数学模型易于认知，他们使用了一般来说3*3的动态缓存重新分配 float data[3][3]，所以当他们用 Matrix 表述两个局部表达式时，整座行列式数据 data[3][3]都将在说明器栈上进行重新分配。虽然整座 Matrix 仅挤占334= 36B 缓存，但或许比基本类别的表达式大很多了，如果行列式的测度是100* 100，两个 Matrix 表达式挤占的缓存将达到近10KB，这种情况下，他们初始化 add(a, b)那个表达式，a 和 b 分别被复本了这份给 ma 和 mb，然后把乘法结果回到给 c 时，又会产生一次临时表达式并分别复本了两次，总计额外复本了4 次共40KB，对于他们的销售业务来说，这些缓存复本操作是昂贵的，而且是多余的。
为何编译器要帮他们自动创建和复本两次临时表达式？表达式传参好认知，因为初始化语义就是fork初始化，肯定要重新重新分配一个新的空间来容纳传入的值；表达式codice稍繁杂一些，他们知道，局部表达式（这里指Matrix对象）重新分配在说明器的栈空间上，当说明器 add(a, b)退出时，本次初始化的栈空间也被自动释放了（栈是后进先出），那当你回到两个局部表达式时，编译器肯定得在外层表达式的栈空间上临时给你重新分配一块新空间，并把刚才表达式退出前的要 return 的栈表达式所占的存储空间的值复本这份过去，然后才敢放心地执行下一行标识符，等效于临时表达式= add(a, b)。因为不这样通过临时及时保护现场的话，下一行标识符初始化新的表达式，原来说明器的栈空间很快就会被新的初始化给征用，原来的局部表达式搞不好就被新的表达式覆盖。然后才执行到 Matrix c =临时表达式，编译器才会把那个没有名字的临时表达式赋值给外层表达式的局部表达式 c，出现第二次复本。虽然现在的编译器大都可以把这种重复复本构建的情形优化掉，但在某些情况，编译器的确还弄不清楚具体的方法论，不敢擅自优化，所以编译器的优化选项不是总是有效。
怎么化解那个难题？使用操作符！操作符就是两个表达式的地址（挤占缓存才几个二进制），他们完全可以传达大表达式的地址给表达式，计算结果也放入指定的地址中：
//行列式演算 V1.1: C 传操作符版void add(Matrix* ma, Matrix* mb, Matrix* mr){ for (int i=; i<3*3; i++) mr->data[i]= ma->data[i]+ mb->data[i];}int main(){ Matrix a ={{{1,2,3},{4,5,6},{7,8,9}}}; Matrix b ={{{2,2,2},{3,3,3},{4,5,6}}}; Matrix result; add(&a,&b,&result); return;}
传操作符的开支几乎可以忽略不计，所以整体效率终于提上去了，但像 add(&a,&b,&result)的书写标识符的形式，以及通过操作符访问内部表达式->的符号实在不太典雅。而且关键是，程式结构设计的思维方式变了，他们时刻想着要传操作符，要提前准备好空表达式（result）让表达式内操作它，这种表达式内部操作外部天然资源的扭曲思想，的确不是两个好法子。
C++说明器：提及传达和操作符重载
为了化解 V1.1版标识符书写难看、思想扭曲的难题，C++在诞生之初，就把那个难题列入关键难题，提出了提及类别。所谓提及，就是绑定到某个对象的别名，相当于两个对象有两条名，他们无论使用哪一条名，效果是一样。他们在新闻稿两个提及时，就必须初始化它，把它绑定到两个对象上。一旦一条别名绑定了两个对象，后续该别名不能再绑定到另两个对象。
Matrix a, b; Matrix* pb =&b;Matrix& ra = a;//把 ra 绑定到 a 上，ra 就是 a//终于可以愉快地使用. 访问成员了，抛弃了丑陋的->ra.data[1][1]= 2.5f; ra = b;// ra 是 a 的两个别名，所以 a 的值也跟着改变ra =*pb //操作符版还得使用丑陋的* 转化为对象
看见了吗，上述标识符中 ra 就是 a，它们是同一个对象，只不过有两条名字而已。提及表述的表达式 ra 本质上是两个操作符（编译器在下层就是这么干的），但它抛弃了操作符那一套操作符号（*和 ->），和对象的使用完全没两样，标识符上直观多了。
可能有人会说，为了这点直观，引入提及那个新的机制，大大增加了词汇的繁杂性，得不偿失。他们换两个视角，C++诞生之初，完全可以抛弃操作符，只用提及那一套，做得像java一样，也是完全可以的。java 中自表述类别都是对象，对象可以传来传去，但要显式使用 new 来创建。java 的对象类别就是 C++的提及类别的加强版。这样的话，就不需要操作符那一套了，是不是让词汇机制更精简？虽然真实世界是 C++要兼容 C 还要保留指针，但他们可以不学它不用它，只学提及，行不行？
事实上，实际项目通常是不会写出上面这样的标识符的，这里只是为了说明提及的概念及基本操作。提及更多是应用领域在表达式的传入传出上：
//行列式演算 V2.0: C++传提及版class Matrix {private: float* data;//数据int rows;//行数int cols;//列数public://构造两个空行列式 Matrix(): rows(), cols(), data(nullptr){}//构造两个 rows * cols 的行列式 Matrix(int rows, int cols): rows(rows), cols(cols){ data = newfloat[rows * cols];} //复本构造两个行列式，深复本 Matrix(const Matrix& m): rows(m.rows), cols(m.cols){ data = newfloat[rows * cols]; memcpy(data, m.data, rows * cols * sizeof(float));} ~Matrix(){ if (data) delete[] data; data = nullptr; rows = cols =; }//下标操作符重载，回到第 i 个元素的提及float& operator[](int i){ return data[i];} //在当前行列式上加上行列式 mvoid add(const Matrix& m){ for (int i=; i < m.rows * m.cols; i++) data[i]= data[i]+ m.data[i];} //+ 操作符重载，回到 a + b 的值friend Matrix operator+(const Matrix& a, const Matrix& b){ Matrix temp(a.rows, a.cols); for (int i=; i < temp.rows * temp.cols; i++) temp.data[i]= a.data[i]+ b.data[i]; return temp;}};int main(){ Matrix a(8,9);//构建两个8 *9 的行列式a a[18]= 5.5f;//给第18个元素赋值，回到引用的简约典雅 Matrix b(a);//构建两个与a拥有一样数据的新行列式b b.add(a);//相当于 b = b + a，传提及效率高 Matrix c(a);//构建两个与a拥有一样数据的新矩阵c Matrix d = b + c;//重载+并传达提及后，标识符极其简约高效率return;}
在表述 Matrix 计算机程序时，区别于 C 版的一般来说3*3的对象缓存重新分配 float data[3][3]，他们在 C++版中使用了堆缓存 data 来保存具体的行列式数据。为了管理好那个堆缓存，他们需要为其编写析构表达式，以便在对象被销毁时能正确释放这块堆缓存；同时他们为其提供复本构造表达式，以实现深复本，避免编译器默认为他们直接复本操作符造成指向同一块缓存，以致于对象释放时被多次释放同一块缓存。
对上述标识符数次使用提及场景的解析如下：
复本构建表达式 Matrix(const Matrix& m)传入了两个（常量）提及作为构建新对象的模板。在该表达式内部，形参 m 是两个提及，被绑定到了实参 a 中，m 就是 a 的两个别名，编译器并不会为 m 在栈中重新分配缓存，因为 m 仅仅是两个别名而已，下层是两个操作符，所以传达效率非常高。因为操作符重载 operator[i]表达式回到了 float&的提及，虽然回到的提及他们没有取名字，是匿名的，但它实现在在绑定到了第i个元素，所以他们可以给它赋值：a[18]= 5.5f;可以看到提及机制和操作符重载的加入，他们才能写出如此典雅简约的C++标识符，Java 都不行！因为 add(const Matrix& a)表达式的形参是 Matrix 的（常量）提及，所以他们在初始化 b.add(a)时，传入的 a 仅仅相当于传了两个操作符，避免了局部对象的创建引起的深度复本。表达式 operator+(a, b)也是传了两个提及，避免了两个局部对象的创建；而且因为重载了+ 操作符，最终的初始化标识符 d = b + c;及其典雅美观简约大方，与内置数据类别一致。只是那个表达式在回到时仍然只能回到局部表达式，造成了编译器为其在上层说明器栈复本构建了两个临时对象，然后那个临时对象给 d 赋值，再一次初始化复本构建表达式，把临时对象深度复本给 d，最终造成额外的两次复本构造。理想的结构设计是，这里应该回到提及，但在 C++11推出右值引出前，他们回到两个局部表达式的提及是非法的，因为局部表达式在表达式回到后即自动销毁，使用它的提及会产生不可预料的后果。所以目前只能容许那个不和谐的声音继续存在。
可以看到，对于 C++98的提及，他们用得更多的是表达式传入模块，以避免临时对象的产生和深度复本开支；而在表达式传出（codice）上，只能回到成员对象的提及，应用领域面很窄。其实，在表达式传出上还有一些特殊的应用领域场景：
回到*this 当前对象的提及，实现链式初始化的程式结构设计效果；回到动态对象的提及，实现单例结构设计模式；
回到提及：链式初始化和链式初始化
还记得他们照着教程写的第两个 C++程序吗？
int main(){ string name, age; cout<<“请输入你的名字：”<< endl; cin>>name>>age; cout<<“你的名字叫”<< name << endl <<“只要我想可以<<到天荒地老”; return;}
他们为何可以连续不断链式追加>>或 <<来输入输出多个表达式？因为 STL 的内置对象 cin 和 cout 的 iostream 类中实现了操作符>>或 <<的重载，关键是，这些重载的表达式中，回到了 this 对象的提及。他们自己的普通表达式（非操作符重载），也可以回到当前对象的提及也实现链式初始化的效果，比如这样：
//行列式演算 V2.1: C++通过回到提及实现链式初始化的程式结构设计方法class Matrix {//…省略 V2.0原来的 Matrix 成员表达式和表达式//新增加如下几个回到本对象提及的表达式 Matrix& rows(int rs){ rows = rs; return *this;} Matrix& cols(int ls){ cols = ls; return *this;} Matrix& build(){ data = newfloat[rows * cols]; return *this;} Matrix& set(float initValue){ memset(data, initValue, rows * cols * sizeof(float)); return *this;}};int main(){ Matrix a(8,9);//构建初始化：两个8 *9 的行列式a Matrix b;//空行列式//链式初始化：设置 b 的测度为8*9，然后构建，然后设置所有元素为1 b.rows(8).cols(9).bulid().set(1.0f);//传统 settor 初始化 Matrix c; c.rows(8); c.cols(9); c.build(); c.set(1.0f); return;}
大家仔细品一下构造初始化、传统settor初始化、链接初始化的优劣势。
构造表达式初始化，必须按照表述的顺序fork，看标识符时没有明确的提示，且不能缺省中间某两个模块；传统 settor 初始化虽然可以灵活的根据需求设置特定某些值，设置的值的意义也很明确，但要挤占多行标识符；链式初始化既简约、又灵活、设置的值的意思还非常明确，特别是要设置的模块很多时，优势更明显；
实现链式初始化的代价，仅仅是在传统的 settor 表达式的最后，回到当前对象的提及即可。性能完全不用担心，因为都是 inline 表达式，编译器会自动帮他们优化。
回到动态对象的提及：最单纯的单例模式
在 C++11之前，实现单例的结构设计模式会稍微麻烦点，但在 C++11之后，因为保证了 static 成员对象构造的原子操作语义，直接回到局部动态对象的提及，即可实现赖汉模式的单例（在第一次初始化时才构建），而且因为回到了提及，他们在使用那个单例对象时，用. 代替了->，标识符看起来更加简约分明。
class FileManager {private://构建表达式被新闻稿为 private，外部不能构造新对象 FileManager()= default;publier;} void createFile(string path);//销售业务表达式};int main(){ FileManager::instance().createFile(“C:\\temp\\haha.txt”); return;}
如果你有耐心读到这里，相信你已经把C++的提及机制的由来、优势和典型应用领域场景等掌控得差不多了，是不是很单纯？实际软件工程建设应用领域上，提及的应用领域场景也就这么些了，如果你能融汇贯通上面的科学知识点并加以应用领域，已经比很多 C++程序员牛了。
