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++中unordered_set哈希集合的实现

C++中unordered_set哈希集合的实现

《C++中unordered_set哈希集合的实现》std::unordered_set是C++标准库中的无序关联容器,基于哈希表实现,具有元素唯一性和无序性特点,本文就来详细的介绍一下unorder... 目录一、概述二、头文件与命名空间三、常用方法与示例1. 构造与析构2. 迭代器与遍历3. 容量相关4
阅读更多...
C++中悬垂引用(Dangling Reference) 的实现

C++中悬垂引用(Dangling Reference) 的实现

《C++中悬垂引用(DanglingReference)的实现》C++中的悬垂引用指引用绑定的对象被销毁后引用仍存在的情况,会导致访问无效内存,下面就来详细的介绍一下产生的原因以及如何避免,感兴趣... 目录悬垂引用的产生原因1. 引用绑定到局部变量，变量超出作用域后销毁2. 引用绑定到动态分配的对象，对象
阅读更多...
JavaScript对象转数组的三种方法实现

JavaScript对象转数组的三种方法实现

《JavaScript对象转数组的三种方法实现》本文介绍了在JavaScript中将对象转换为数组的三种实用方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友... 目录方法1：使用Object.keys()和Array.map()方法2：使用Object.entr
阅读更多...
Python内存管理机制之垃圾回收与引用计数操作全过程

Python内存管理机制之垃圾回收与引用计数操作全过程

《Python内存管理机制之垃圾回收与引用计数操作全过程》SQLAlchemy是Python中最流行的ORM（对象关系映射）框架之一,它提供了高效且灵活的数据库操作方式,本文将介绍如何使用SQLAlc... 目录安装核心概念连接数据库定义数据模型创建数据库表基本CRUD操作创建数据读取数据更新数据删除数据查
阅读更多...
C++读写word文档(.docx)DuckX库的使用详解

C++读写word文档(.docx)DuckX库的使用详解

《C++读写word文档(.docx)DuckX库的使用详解》DuckX是C++库,用于创建/编辑.docx文件,支持读取文档、添加段落/片段、编辑表格,解决中文乱码需更改编码方案,进阶功能含文本替换... 目录一、基本用法1. 读取文档3. 添加段落4. 添加片段3. 编辑表格二、进阶用法1. 文本替换2
阅读更多...
使用MapStruct实现Java对象映射的示例代码

使用MapStruct实现Java对象映射的示例代码

《使用MapStruct实现Java对象映射的示例代码》本文主要介绍了使用MapStruct实现Java对象映射的示例代码,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,... 目录一、什么是 MapStruct？二、实战演练：三步集成 MapStruct第一步：添加 Mave
阅读更多...
C++中处理文本数据char与string的终极对比指南

C++中处理文本数据char与string的终极对比指南

《C++中处理文本数据char与string的终极对比指南》在C++编程中char和string是两种用于处理字符数据的类型,但它们在使用方式和功能上有显著的不同,：本文主要介绍C++中处理文本数... 目录1. 基本定义与本质2. 内存管理3. 操作与功能4. 性能特点5. 使用场景6. 相互转换核心区别
阅读更多...
Java中实现对象的拷贝案例讲解

Java中实现对象的拷贝案例讲解

《Java中实现对象的拷贝案例讲解》Java对象拷贝分为浅拷贝（复制值及引用地址）和深拷贝（递归复制所有引用对象）,常用方法包括Object.clone()、序列化及JSON转换,需处理循环引用问题,... 目录对象的拷贝简介浅拷贝和深拷贝浅拷贝深拷贝深拷贝和循环引用总结对象的拷贝简介对象的拷贝，把一个
阅读更多...
MySQL8.0临时表空间的使用及解读

MySQL8.0临时表空间的使用及解读

《MySQL8.0临时表空间的使用及解读》MySQL8.0+引入会话级（temp_N.ibt）和全局（ibtmp1）InnoDB临时表空间,用于存储临时数据及事务日志,自动创建与回收,重启释放,管理高... 目录一、核心概念：为什么需要“临时表空间”？二、InnoDB 临时表空间的两种类型1. 会话级临时表
阅读更多...
C++右移运算符的一个小坑及解决

C++右移运算符的一个小坑及解决

《C++右移运算符的一个小坑及解决》文章指出右移运算符处理负数时左侧补1导致死循环,与除法行为不同,强调需注意补码机制以正确统计二进制1的个数... 目录我遇到了这么一个www.chinasem.cn函数由此可以看到也很好理解总结我遇到了这么一个函数template<typename T>unsigned
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2