C++非const的引用不能指向临时对象

2024-08-28 04:38
文章标签 c++ 引用 对象 不能 const 指向 临时

本文主要是介绍C++非const的引用不能指向临时对象，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

C++标准的规定：非常量的引用不能指向临时对象

例如：

const string &temp = "c++"; 是正确的。

但是string &temp = “c++”; 是错误的，因为该语句首先调用string的构造函数，生成一个临时对象，但是将该临时对象复制给一个非const的引用temp就是错误的。

----------------------------------------------分割线----------------------------------------------------------

C++中有这样一种对象：它在代码中看不到，但是确实存在。它就是临时对象---由编译器定义的一个没有命名的非堆对象（non-heap object）。为什么研究临时对象？主要是为了提高程序的性能以及效率，因为临时对象的构造与析构对系统性能而言绝不是微小的影响，所以我们应该去了解它们，知道它们如何造成，从而尽可能去避免它们。

临时对象通常产生于以下4种情况：

  1. 类型装换
  2. 按值传递
  3. 按值返回
  4. 对象定义

下面我们逐一看看：

1、类型转换

它通常是为了让函数调用成功而产生临时对象。发生于 “传递某对象给一个函数，而其类型与它即将绑定上去的参数类型不同” 的时候。

例如：

[cpp] view plain copy
  1. void test(const string& str);  
  2.   
  3. char buffer[] = "buffer";  
  4.   
  5. test(buffer); // 此时发生类型转换  

此时，编译器会帮你进行类型转换：它产生一个类型为string的临时对象，该对象以buffer为参数调用string constructor。当test函数返回时，此临时对象会被自动销毁。

注意：对于引用（reference）参数而言，只有当对象被传递给一个reference-to-const参数时，转换才发生。如果对象传递给一个reference-to-non-const对象，不会发生转换。

例如：

[cpp] view plain copy
  1. void upper（string& str);  
  2.   
  3. char lower[] = "lower";  
  4.   
  5. upper(lower); // 此时不能转换，编译出错  

此时如果编译器对reference-to-non-const对象进行了类型转换，那么将会允许临时对象的值被修改。而这和程序员的期望是不一致的。试想，在上面的代码中，如果编译器允许upper运行，将lower中的值转换为大写，但是这是对临时对象而言的，char lower[]的值还是“lower”，这和你的期望一致吗？

有时候，这种隐式类型转换不是我们期望的，那么我们可以通过声明constructor为explicit来实现。explicit告诉编译器，我们反对将constructor用于类型转换。

例如：

[cpp] view plain copy
  1. explicit string(const char*);  

2、按值传递

这通常也是为了让函数调用成功而产生临时对象。当按值传递对象时，实参对形参的初始化与T formalArg = actualArg的形式等价。

例如：

[cpp] view plain copy
  1. void test（T formalArg);  
  2.   
  3. T actualArg;  
  4. test(actualArg);  

此时编译器产生的伪码为：
[cpp] view plain copy
  1. T _temp;  
  2.   
  3. _temp.T::T(acutalArg); // 通过拷贝构造函数生成_temp  
  4. g(_temp);  // 按引用传递_temp  
  5. _temp.T::~T(); // 析构_temp  

因为存在局部参数formalArg，test（）的调用栈中将存在formalArg的占位符。编译器必须复制对象actualArg的内容到formalArg的占位符中。所以，此时编译器生成了临时对象。

另一个例子：

void upper(string& str) {
}
int main() {upper(string("aa"));
}
在VS2010下编译运行没错；在g++(gcc 4.4.3)下出错： 
test.cpp:30: error: invalid initialization of non-const reference of type ‘std::string&’ from a temporary of type ‘std::string’
test.cpp:28: error: in passing argument 1 of ‘void test(std::string&)’
虽然main函数中显示用string的构造函数产生了临时对象作为upper函数的参数，但是upper函数形参为非const引用，因此非const的引用指向临时对象，所以出错。

3、按值返回

如果函数是按值返回的，那么编译器很可能为之产生临时对象。

例如：

[cpp] view plain copy
  1. class Integer {  
  2. public:  
  3.   friend Integer operator+(const Integer& a, const Integer& b);  
  4.     
  5.   Integer(int val=0): value(val) {  
  6.   }  
  7.     
  8.   Integer(const Integer& rhs): value(rhs.value) {  
  9.   }  
  10.     
  11.   Integer& operator=(const Integer& rhs);  
  12.     
  13.   ~Integer() {  
  14.   }  
  15.     
  16. private:  
  17.   int value;    
  18. };  
  19.   
  20. Integer operator+(const Integer& a, const Integer& b) {  
  21.   Integer retVal;  
  22.     
  23.   retVal.value = a.value + b.value;  
  24.     
  25.   return retVal;  
  26. }  
  27.   
  28. Integer c1, c2, c3;  
  29. c3 = c1 + c2;  

编译器生成的伪代码：
[cpp] view plain copy
  1. struct Integer _tempResult; // 表示占位符，不调用构造函数  
  2. operator+(_tempResult, c1, c2); // 所有参数按引用传递  
  3. c3 = _tempResult; // operator=函数执行  
  4.   
  5. Integer operator+(const Integer& _tempResult, const Integer& a, const Integer& b) {  
  6.   struct Integer retVal;  
  7.   retVal.Integer::Integer(); // Integer(int val=0)执行  
  8.     
  9.   retVal.value = a.value + b.value;  
  10.     
  11.   _tempResult.Integer::Integer(retVal); // 拷贝构造函数Integer(const Integer& rhs)执行，生成临时对象。  
  12.     
  13.   retVal.Integer::~Integer(); // 析构函数执行  
  14.     
  15.   return;  
  16. }  
  17.     
  18.   return retVal;  
  19. }  

如果对operator+进行 返回值优化（RVO：Return Value Optimization），那么临时对象将不会产生。

例如：

[cpp] view plain copy
  1. Integer operator+(const Integer& a, const Integer& b) {    
  2.   return Integer(a.value + b.value);  
  3. }  

编译器生成的伪代码：
[cpp] view plain copy
  1. Integer operator+(const Integer& _tempResult, const Integer& a, const Integer& b) {  
  2.   _tempResult.Integer::Integer(); // Integer(int val=0)执行  
  3.   _tempResult.value = a.value + b.value;  
  4.     
  5.   return;  
  6. }  

对照上面的版本，我们可以看出临时对象retVal消除了。


另外一个例子：

#include <iostream>
#include <string>
using namespace std;class Person {
public:Person::Person(string n = "a", string a = "b") {name = n;address = a;}void display() {cout << name << " " << address << endl;}
private:string name;string address;
};//test函数返回一个Person类对象
Person test() {Person per;return per;
}
int main() {//Person类的非const引用指向test函数返回值Person& pa = test(); 
}
如上的程序在VS2010下编译运行没有错误；但是在g++(gcc version 4.4.3)下编译出错： 
test.cpp:33: error: invalid initialization of non-const reference of type ‘Person&’ from a temporary of type ‘Person’
按照本文开始所述的几种产生临时对象的类别看，test函数的返回会产生一个Person类的临时对象，而 main函数中用非const的引用指向该临时对象，而“C++不允许将非const的引用指向临时对象”，因此，g++编译出错（在main函数中为引用pa加上const就不会出错）。而VS之所以没出错，是因为VS在编译时由编译器做优化（返回值优化）了：test函数不会产生临时对象，而是将test函数编译为类似下面的结果： 

void test(Person& __result) {__result.Person::Person();return;
}
如上的优化结果表明test函数并不会产生一个临时对象。

4、对象定义：

例如：

[cpp] view plain copy
  1. Integer i1(100); // 编译器肯定不会生成临时对象  
  2. Integer i2 = Integer(100); // 编译器可能生成临时对象  
  3. Integer i3 = 100; // 编译器可能生成临时对象  

然而，实际上大多数的编译器都会通过优化省去临时对象，所以这里的初始化形式基本上在效率上都是相同的。


备注：

临时对象的生命期：按照C++标准的说法，临时对象的摧毁，是对完整表达式求值过程中的最后一个步骤。该完整表达式照成了临时对象的产生。

完整表达式通常是指包含临时对象表达式的最外围的那个。例如：

（（objA >1024）&&（objB <1024） ） ？ （objA - objB） ：（objB-objA）

这个表达式中一共含有5个表达式，最外围的表达式是？。任何一个子表达式所产生的任何一个临时对象，都应该在完整表达式被求值完成后，才可以销毁。

临时对象的生命周期规则有2个例外：

1、在表达式被用来初始化一个object时。例如：

[cpp] view plain copy
  1. String progName("test");  
  2. String progVersion("ver-1.0");  
  3. String progNameVersion = progName + progVersion  

如果progName + progVersion产生的临时对象在表达式求值结束后就析构，那么progNameVersion就无法产生。所以，C++标准规定：含有表达式执行结果的临时对象，应该保留到object的初始化操作完成为止。

小心这种情况：

[cpp] view plain copy
  1. const char* progNameVersion = progName + progVersion  

这个初始化操作是一定会失败的。编译器产生的伪码为：
[cpp] view plain copy
  1. String _temp;  
  2. operator+(_temp, progName, progVersion);  
  3. progNameVersion = _temp.String::operator char*();  
  4. _temp.String::~String();  

2、当一个临时对象被一个reference绑定时。例如：
[cpp] view plain copy
  1. const String& name = "C++";  

编译器产生的伪码为：
[cpp] view plain copy
  1. String _temp;  
  2. temp.String::String("C++");  
  3. const String& name = _temp;  

针对这种情况，C++标准上是这样说的：如果一个临时对象被绑定于一个reference，对象将保留，直到被初始化的reference的生命结束，或直到临时对象的生命范围结束-----看哪种情况先到达而定。


参考书籍：

1、《深度探索：C++对象模型》

2、《提高C++性能的编程技术》

3、《Effective C++》

4、《more effective C++》

5、《C++语言的设计和演化》

转载自：

http://blog.csdn.net/imyfriend/article/details/12886577


这篇关于C++非const的引用不能指向临时对象的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1113754。

相关文章

C++统计函数执行时间的最佳实践

C++统计函数执行时间的最佳实践

《C++统计函数执行时间的最佳实践》在软件开发过程中,性能分析是优化程序的重要环节,了解函数的执行时间分布对于识别性能瓶颈至关重要,本文将分享一个C++函数执行时间统计工具,希望对大家有所帮助... 目录前言工具特性核心设计1. 数据结构设计2. 单例模式管理器3. RAII自动计时使用方法基本用法高级用法
阅读更多...
深入解析C++ 中std::map内存管理

深入解析C++ 中std::map内存管理

《深入解析C++中std::map内存管理》文章详解C++std::map内存管理,指出clear()仅删除元素可能不释放底层内存,建议用swap()与空map交换以彻底释放,针对指针类型需手动de... 目录1️、基本清空std::map2️、使用 swap 彻底释放内存3️、map 中存储指针类型的对象
阅读更多...
使用Java读取本地文件并转换为MultipartFile对象的方法

使用Java读取本地文件并转换为MultipartFile对象的方法

《使用Java读取本地文件并转换为MultipartFile对象的方法》在许多JavaWeb应用中,我们经常会遇到将本地文件上传至服务器或其他系统的需求,在这种场景下,MultipartFile对象非... 目录1. 基本需求2. 自定义 MultipartFile 类3. 实现代码4. 代码解析5. 自定
阅读更多...
C++ STL-string类底层实现过程

C++ STL-string类底层实现过程

《C++STL-string类底层实现过程》本文实现了一个简易的string类,涵盖动态数组存储、深拷贝机制、迭代器支持、容量调整、字符串修改、运算符重载等功能,模拟标准string核心特性,重点强... 目录实现框架一、默认成员函数1.默认构造函数2.构造函数3.拷贝构造函数(重点)4.赋值运算符重载函数
阅读更多...
C++ vector越界问题的完整解决方案

C++ vector越界问题的完整解决方案

《C++vector越界问题的完整解决方案》在C++开发中,std::vector作为最常用的动态数组容器,其便捷性与性能优势使其成为处理可变长度数据的首选,然而,数组越界访问始终是威胁程序稳定性的... 目录引言一、vector越界的底层原理与危害1.1 越界访问的本质原因1.2 越界访问的实际危害二、基
阅读更多...
MySQL 临时表与复制表操作全流程案例

MySQL 临时表与复制表操作全流程案例

《MySQL临时表与复制表操作全流程案例》本文介绍MySQL临时表与复制表的区别与使用,涵盖生命周期、存储机制、操作限制、创建方法及常见问题,本文结合实例代码给大家介绍的非常详细,感兴趣的朋友跟随小... 目录一、mysql 临时表（一）核心特性拓展（二）操作全流程案例1. 复杂查询中的临时表应用2. 临时
阅读更多...
MySQL 临时表创建与使用详细说明

MySQL 临时表创建与使用详细说明

《MySQL临时表创建与使用详细说明》MySQL临时表是存储在内存或磁盘的临时数据表,会话结束时自动销毁,适合存储中间计算结果或临时数据集,其名称以#开头（如#TempTable）,本文给大家介绍M... 目录mysql 临时表详细说明1.定义2.核心特性3.创建与使用4.典型应用场景5.生命周期管理6.注
阅读更多...
c++日志库log4cplus快速入门小结

c++日志库log4cplus快速入门小结

《c++日志库log4cplus快速入门小结》文章浏览阅读1.1w次，点赞9次，收藏44次。本文介绍Log4cplus，一种适用于C++的线程安全日志记录API，提供灵活的日志管理和配置控制。文章涵盖... 目录简介日志等级配置文件使用关于初始化使用示例总结参考资料简介log4j 用于Java，log4c
阅读更多...
C++归并排序代码实现示例代码

C++归并排序代码实现示例代码

《C++归并排序代码实现示例代码》归并排序将待排序数组分成两个子数组,分别对这两个子数组进行排序,然后将排序好的子数组合并,得到排序后的数组,：本文主要介绍C++归并排序代码实现的相关资料,需要的... 目录1 算法核心思想2 代码实现3 算法时间复杂度1 算法核心思想归并排序是一种高效的排序方式，需要用
阅读更多...
javaSE类和对象进阶用法举例详解

javaSE类和对象进阶用法举例详解

《javaSE类和对象进阶用法举例详解》JavaSE的面向对象编程是软件开发中的基石,它通过类和对象的概念,实现了代码的模块化、可复用性和灵活性,：本文主要介绍javaSE类和对象进阶用法的相关资... 目录前言一、封装1.访问限定符2.包2.1包的概念2.2导入包2.3自定义包2.4常见的包二、stati
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2