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。

相关文章

在java中如何将inputStream对象转换为File对象(不生成本地文件)

在java中如何将inputStream对象转换为File对象(不生成本地文件)

《在java中如何将inputStream对象转换为File对象(不生成本地文件)》：本文主要介绍在java中如何将inputStream对象转换为File对象(不生成本地文件),具有很好的参考价... 目录需求说明问题解决总结需求说明在后端中通过POI生成Excel文件流，将输出流（outputStre
阅读更多...
C++ 中的 if-constexpr语法和作用

C++ 中的 if-constexpr语法和作用

《C++中的if-constexpr语法和作用》if-constexpr语法是C++17引入的新语法特性,也被称为常量if表达式或静态if（staticif）,：本文主要介绍C++中的if-c... 目录1 if-constexpr 语法1.1 基本语法1.2 扩展说明1.2.1 条件表达式1.2.2 fa
阅读更多...
C++中::SHCreateDirectoryEx函数使用方法

C++中::SHCreateDirectoryEx函数使用方法

《C++中::SHCreateDirectoryEx函数使用方法》::SHCreateDirectoryEx用于创建多级目录,类似于mkdir-p命令,本文主要介绍了C++中::SHCreateDir... 目录1. 函数原型与依赖项2. 基本使用示例示例 1：创建单层目录示例 2：创建多级目录3. 关键注
阅读更多...
C++从序列容器中删除元素的四种方法

C++从序列容器中删除元素的四种方法

《C++从序列容器中删除元素的四种方法》删除元素的方法在序列容器和关联容器之间是非常不同的,在序列容器中,vector和string是最常用的,但这里也会介绍deque和list以供全面了解,尽管在一... 目录一、简介二、移除给定位置的元素三、移除与某个值相等的元素3.1、序列容器vector、deque
阅读更多...
C++常见容器获取头元素的方法大全

C++常见容器获取头元素的方法大全

《C++常见容器获取头元素的方法大全》在C++编程中,容器是存储和管理数据集合的重要工具,不同的容器提供了不同的接口来访问和操作其中的元素,获取容器的头元素（即第一个元素）是常见的操作之一,本文将详细... 目录一、std::vector二、std::list三、std::deque四、std::forwa
阅读更多...
Linux修改pip临时目录方法的详解

Linux修改pip临时目录方法的详解

《Linux修改pip临时目录方法的详解》在Linux系统中,pip在安装Python包时会使用临时目录（TMPDIR）,但默认的临时目录可能会受到存储空间不足或权限问题的影响,所以本文将详细介绍如何... 目录引言一、为什么要修改 pip 的临时目录？1. 解决存储空间不足的问题2. 解决权限问题3. 提
阅读更多...
C++字符串提取和分割的多种方法

C++字符串提取和分割的多种方法

《C++字符串提取和分割的多种方法》在C++编程中,字符串处理是一个常见的任务,尤其是在需要从字符串中提取特定数据时,本文将详细探讨如何使用C++标准库中的工具来提取和分割字符串,并分析不同方法的适用... 目录1. 字符串提取的基本方法1.1 使用 std::istringstream 和 >> 操作符示
阅读更多...
C++原地删除有序数组重复项的N种方法

C++原地删除有序数组重复项的N种方法

《C++原地删除有序数组重复项的N种方法》给定一个排序数组,你需要在原地删除重复出现的元素,使得每个元素只出现一次,返回移除后数组的新长度,不要使用额外的数组空间,你必须在原地修改输入数组并在使用O(... 目录一、问题二、问题分析三、算法实现四、问题变体：最多保留两次五、分析和代码实现5.1、问题分析5.
阅读更多...
C++ 各种map特点对比分析

C++ 各种map特点对比分析

《C++各种map特点对比分析》文章比较了C++中不同类型的map（如std::map,std::unordered_map,std::multimap,std::unordered_multima... 目录特点比较C++ 示例代码 ​​​​​​代码解释特点比较1. std::map底层实现：基于红黑
阅读更多...
C++中函数模板与类模板的简单使用及区别介绍

C++中函数模板与类模板的简单使用及区别介绍

《C++中函数模板与类模板的简单使用及区别介绍》这篇文章介绍了C++中的模板机制,包括函数模板和类模板的概念、语法和实际应用,函数模板通过类型参数实现泛型操作,而类模板允许创建可处理多种数据类型的类,... 目录一、函数模板定义语法真实示例二、类模板三、关键区别四、注意事项 ‌在C++中，模板是实现泛型编程
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2