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++库

《C#如何调用C++库》：本文主要介绍C#如何调用C++库方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录方法一：使用P/Invoke1. 导出C++函数2. 定义P/Invoke签名3. 调用C++函数方法二：使用C++/CLI作为桥接1. 创建C++/CL
阅读更多...
Spring 中的循环引用问题解决方法

Spring 中的循环引用问题解决方法

《Spring中的循环引用问题解决方法》：本文主要介绍Spring中的循环引用问题解决方法,本文给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友参考下吧... 目录什么是循环引用？循环依赖三级缓存解决循环依赖二级缓存三级缓存本章来聊聊Spring 中的循环引用问题该如何解决。这里聊
阅读更多...
Java对象转换的实现方式汇总

Java对象转换的实现方式汇总

《Java对象转换的实现方式汇总》：本文主要介绍Java对象转换的多种实现方式,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友参考下吧... 目录Java对象转换的多种实现方式1. 手动映射（Manual Mapping）2. Builder模式3. 工具类辅助映
阅读更多...
C++如何通过Qt反射机制实现数据类序列化

C++如何通过Qt反射机制实现数据类序列化

《C++如何通过Qt反射机制实现数据类序列化》在C++工程中经常需要使用数据类,并对数据类进行存储、打印、调试等操作,所以本文就来聊聊C++如何通过Qt反射机制实现数据类序列化吧... 目录设计预期设计思路代码实现使用方法在 C++ 工程中经常需要使用数据类，并对数据类进行存储、打印、调试等操作。由于数据类
阅读更多...
SpringBoot内嵌Tomcat临时目录问题及解决

SpringBoot内嵌Tomcat临时目录问题及解决

《SpringBoot内嵌Tomcat临时目录问题及解决》：本文主要介绍SpringBoot内嵌Tomcat临时目录问题及解决,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,... 目录SprinjavascriptgBoot内嵌Tomcat临时目录问题1.背景2.方案3.代码中配置t
阅读更多...
Linux下如何使用C++获取硬件信息

Linux下如何使用C++获取硬件信息

《Linux下如何使用C++获取硬件信息》这篇文章主要为大家详细介绍了如何使用C++实现获取CPU,主板,磁盘,BIOS信息等硬件信息,文中的示例代码讲解详细,感兴趣的小伙伴可以了解下... 目录方法获取CPU信息：读取"/proc/cpuinfo"文件获取磁盘信息：读取"/proc/diskstats"文
阅读更多...
C++使用printf语句实现进制转换的示例代码

C++使用printf语句实现进制转换的示例代码

《C++使用printf语句实现进制转换的示例代码》在C语言中,printf函数可以直接实现部分进制转换功能,通过格式说明符（formatspecifier）快速输出不同进制的数值,下面给大家分享C+... 目录一、printf 原生支持的进制转换1. 十进制、八进制、十六进制转换2. 显示进制前缀3. 指
阅读更多...
Python中判断对象是否为空的方法

Python中判断对象是否为空的方法

《Python中判断对象是否为空的方法》在Python开发中,判断对象是否为“空”是高频操作,但看似简单的需求却暗藏玄机,从None到空容器,从零值到自定义对象的“假值”状态,不同场景下的“空”需要精... 目录一、python中的“空”值体系二、精准判定方法对比三、常见误区解析四、进阶处理技巧五、性能优化
阅读更多...
C++中初始化二维数组的几种常见方法

C++中初始化二维数组的几种常见方法

《C++中初始化二维数组的几种常见方法》本文详细介绍了在C++中初始化二维数组的不同方式,包括静态初始化、循环、全部为零、部分初始化、std::array和std::vector,以及std::vec... 目录1. 静态初始化2. 使用循环初始化3. 全部初始化为零4. 部分初始化5. 使用 std::a
阅读更多...
C++ vector的常见用法超详细讲解

C++ vector的常见用法超详细讲解

《C++vector的常见用法超详细讲解》：本文主要介绍C++vector的常见用法,包括C++中vector容器的定义、初始化方法、访问元素、常用函数及其时间复杂度,通过代码介绍的非常详细,... 目录1、vector的定义2、vector常用初始化方法1、使编程用花括号直接赋值2、使用圆括号赋值3、ve
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2