C++中的临时对象和局部对象

C++的临时变量
它们是被神所遗弃的孩子,没有人见过它们,更没有人知道它们的名字.它们命中注定徘徊于命运边缘高耸的悬崖和幽深的深渊之间,
用自己短暂的生命抚平了生与死之间的缝隙.譬如朝露,却与阳光无缘.是该为它们立一座丰碑的时候了,墓铭志上写着:我来了,我走了,我快乐过.

许多人对临时变量的理解仅仅限于:
string temp;
其实,从C++的观点来看,这根本就不是临时变量,而是局部变量.

C++的临时变量是编译器在需要的时候自动生成的临时性变量,它们并不在代码中出现.但是它们在编译器生成的二进制编码中是存在的,
也创建和销毁.在C++语言中,临时变量的问题格外的重要,因为每个用户自定义类型的临时变量都要出发用户自定义的构造函数和析构函数(如果用户提供了)

又是该死的编译器!又该有人抱怨编译器总在自己背后干着偷偷摸摸的事情了.但是如果离开了编译器的这些工作,我们可能寸步难行.

如果X是一个用户自定义的类型,有默认构造函数,拷贝构造函数,赋值运算函数,析构函数(这也是类的4个基本函数),那么请考虑以下代码:
X get(X arg)
{
return arg;
}

X a;
X b = get(a);
即使是这么简单的代码也是很难实现的

让我们分析一下代码执行过程中发生了什么?
首先我要告诉你一个秘密:对于一个函数来说,无论是传入一个对象还是传出一个对象其实都是不可能的.
让一个函数传入或传出一个内置的数据类型,例如int,是很容易的,但是对于用户自定义类型得对象却非常的困难,因为编译器总得找地方为这些对象
写上构造函数和析构函数,不是在函数内,就是在函数外,除非你用指针或引用跳过这些困难

那么怎么办?在这里,编译器必须玩一些必要的小花招,嗯,其中的关键恰恰就是临时变量

对于以对象为形参的函数:
void foo(X x0)
{
}

X xx;
foo(xx);

编译器一般按照以下两种转换方式中的一种进行转换
1.在函数外提供临时变量
void foo(X& x0)   //修改foo的声明为引用
{
}
X xx;        //声明xx
X::X(xx);      //调用xx的默认构造函数
X __temp0;     //声明临时变量__temp0
X::X(__temp0, xx); //调用__temp0的拷贝构造函数
foo(__temp0);    //调用foo
X::~X(__temp0);   //调用__temp0的析构函数
X::~X(xx);     //调用xx的析构函数

2.在函数内提供临时变量
void foo(X& x0)   //修改foo的声明为引用
{
X __temp0;     //声明临时变量__temp0
X::X(__temp0, x0); //调用__temp0的拷贝构造函数
X::~X(__temp0);   //调用__temp0的析构函数
}
X xx;        //声明xx
X::X(xx);      //调用xx的默认构造函数
foo(xx);      //调用foo
X::~X(xx);     //调用xx的析构函数

无论是在函数的内部声明临时变量还是在函数的外部声明临时变量,其实都是差不多的,这里的含义是说既然参数要以传值的
语意传入函数,也就是实参xx其实并不能修改,那么我们就用一个一摸一样临时变量来移花接木,完成这个传值的语意
但是这样做也不是没有代价,编译器要修改函数的声明,把对象改为对象的引用,同时修改所有函数调用的地方,代价确实巨大啊,
但是这只是编译器不高兴而已,程序员和程序执行效率却没有影响

对于以对象为返回值的函数:
X foo()
{
X xx;
return xx;
}

X yy = foo();

编译器一般按照以下方式进行转换
void foo(X& __temp0) //修改foo的声明为引用
{
X xx;        //声明xx
X::X(xx);      //调用xx的默认构造函数

__temp0::X::X(xx); //调用__temp0的拷贝构造函数
X::~X(xx);     //调用xx的析构函数
}

X yy;         //声明yy
X __temp0;      //声明临时变量__temp0
foo(__temp0);     //调用foo
X::X(yy, __temp0);  //调用yy的拷贝构造函数
X::~X(__temp0);    //调用__temp0的析构函数
X::~X(yy);      //调用yy的析构函数

既然我们已经声明了yy,为什么还要紧接着声明__temp0,其实这里完全可以把yy和临时变量合一
优化后,上面的代码看起来象这个样子:
void foo(X& __temp0) //修改foo的声明为引用
{
X xx;        //声明xx
X::X(xx);      //调用xx的默认构造函数

__temp0::X::X(xx); //调用__temp0的拷贝构造函数
X::~X(xx);     //调用xx的析构函数
}

X yy;         //声明yy
foo(yy);       //调用foo
X::~X(yy);      //调用yy的析构函数

嗯,怎么说呢,这算是一种优化算法吧,其实这各个技巧已经非常普遍了,并拥有一个专门的名称Named Return Value(NRV)优化
NRV优化如今被视为标准C++编译器的一个义不容辞的优化操作(虽然其需求其实超出了正式标准之外)

除了以类为参数以外,如果参数的类型是const T&类型,这也可能导致临时变量
void fun(const string& str)
const char* name = "wgs";
fun(name);
嗯,还记得在const文档中的论述吗?对于这种特殊的参数类型,编译器是很乐意为你做自动转换的工作的,代价嘛,就是一个临时变量,
不过如果是你自己去做,大概就只能声明一个局部变量了

为什么函数和临时变量这么有缘,其实根本的原因在于对象传值的语意,这一个也是为什么C++中鼓励传对象地址的原因

和函数的情况类似的,还有一大类情况是临时变量的乐土,那就是表达式
string s,t;
printf("%s", s + t);
这里s+t的结果该放在什么地方呢?只能是临时变量中.

这个printf语句带来了新的问题,那就是"临时变量的生命期"是如何的?
对于函数的情况,我们已经看到了,临时变量在完成交换内容的使命后都是尽量早的被析构了,那么对于表达式呢?
如果在s+t计算后析构,那么print函数打印的就是一个非法内容了,因此C++给出的规则是:
临时变量应该在导致临时变量创建的"完整表达式"求值过程的最后一个步骤被析构
什么又是"完整表达式"?简单的说,就是不是表达式的子表达式
这条规则听起来很简单,但具体实现起来就非常的麻烦了,例如:
X foo(int n)
if (foo(1) || foo(2) || foo(3) )
其中X中有operator int()转换,所以可以用在if语句中
这里的foo(1)将产生一个临时变量1,如果这部分为false,foo(2)将继续产生一个临时变量,如果这部分也为false,foo(3)...
一个临时变量的参数居然是和运行时相关的,更要命的是你要记住你到底产生了几个临时变量并在这个表达式结束的时候进行析构以小心的维护对象构造和析构的一致
我猜想,这里会展开成一段复杂的代码,并加入更多的if判断才能搞定,呵呵,好在我不是做编译器的

上面的规则其实还有两条例外:
string s,t;
string v = 1 ? s + t : s - t;
这里完整表达式是?语句,但是在完整表达式结束以后临时变量还不能立即销毁,而必须在变量v赋值完成后才能销毁,这就是例外规则1:
凡含有表达式执行结果的临时变量,应该存留到对象的初始化操作完成后销毁

string s,t;
string& v = s + t;
这里s+t产生的临时变量即使在变量v的赋值完成后也不能销毁,否则这个引用就没用了,这就是例外规则2:
如果一个临时变量被绑定到一个引用,这个临时变量应该留到这个临时变量和这个引用那个先超出变量的作用域后才销毁

这篇文章可能有些深奥了,毕竟大多数内容来自于<<Inside The C++ Object Model>>
那么就留下一条忠告:
在stl中,以下的代码是错误的
string getName();
char* pTemp = getName().c_str();
getName返回的就是一个临时变量,在把它内部的char指针赋值给pTemp后析构了,这时pTemp就是一个非法地址
确实如C++发明者Bjarne Stroustrup所说,这种情况一般发生在不同类型的相互转换上

在Qt中,类似的代码是这样的
QString getName();
char* pTemp = getName().toAscii().data();
这时pTemp是非法地址

希望大家不要犯类似的错误

--------------------------------------------------------------------------
C++中的临时对象

程序员间交谈时，经常把仅仅需要一小段时间的变量称为临时变量。例如在下面这段swap(交换)例程里：
template<class T>
void swap(T& object1, T& object2)
{
T temp = object1;
object1 = object2;
object2 = temp;
}

通常把temp叫做临时变量。不过就C++而言，temp根本不是临时变量，它只是一个函数的局部对象。
在C++中真正的临时对象是看不见的，它们不出现在我们的源代码中。建立一个没有命名的非堆（non-heap）对象会产生临时对象。这种未命名的对象通常在两种条件下产生：为了使函数成功调用而进行隐式类型转换和函数返回对象时。理解如何和为什么建立这些临时对象是很重要的，因为构造和释放它们的开销对于程序的性能来说有着不可忽视的影响。

首先考虑为使函数成功调用而建立临时对象这种情况。当传送给函数的对象类型与参数类型不匹配时会产生这种情况。例如一个函数，它用来计算一个字符在字符串中出现的次数：
// 返回ch在str中出现的次数
size_t countChar(const string& str, char ch);
char buffer[MAX_STRING_LEN];
char c;
// 读入到一个字符和字符串中，用setw避免缓存溢出，当读取一个字符串时
cin >> c >> setw(MAX_STRING_LEN) >> buffer;
cout << "There are " << countChar(buffer, c)
<< " occurrences of the character " << c
<< " in " << buffer << endl;

看一下countChar的调用。第一个被传送的参数是字符数组，但是对应函数的正被绑定的参数的类型是const string&。仅当消除类型不匹配后，才能成功进行这个调用，编译器很乐意替你消除它，方法是建立一个string类型的临时对象。通过以buffer做为参数调用string的构造函数来初始化这个临时对象。countChar的参数str被绑定在这个临时的string对象上。当countChar返回时，临时对象自动释放。

这样的类型转换很方便（尽管很危险），但是从效率的观点来看，临时string对象的构造和释放是不必要的开销。通常有两个方法可以消除它。一种是重新设计代码，不让发生这种类型转换。另一种方法是通过修改软件而不再需要类型转换。

仅当通过传值（by value）方式传递对象或传递常量引用（reference-to-const）参数时，才会发生这些类型转换。当传递一个非常量引用（reference-to-non-const）参数对象，就不会发生。考虑一下这个函数：
void uppercasify(string& str);               // 把str中所有的字符
// 改变成大写

在字符计数的例子里，能够成功传递char数组到countChar中，但是在这里试图用char数组调用upeercasify函数，则不会成功：
char subtleBookPlug[] = "Effective C++";
uppercasify(subtleBookPlug);                // 错误!

没有为使调用成功而建立临时对象，为什么呢？
假设建立一个临时对象，那么临时对象将被传递到upeercasify中，其会修改这个临时对象，把它的字符改成大写。但是对subtleBookPlug函数调用的真正参数没有任何影响；仅仅改变了临时从subtleBookPlug生成的string对象。无疑这不是程序员所希望的。程序员传递subtleBookPlug参数到uppercasify函数中，期望修改subtleBookPlug的值。当程序员期望修改非临时对象时，对非常量引用（references-to-non-const）进行的隐式类型转换却修改临时对象。这就是为什么C++语言禁止为非常量引用（reference-to-non-const）产生临时对象。这样非常量引用（reference-to-non-const）参数就不会遇到这种问题。

建立临时对象的第二种环境是函数返回对象时。例如operator+必须返回一个对象，以表示它的两个操作数的和。例如给定一个类型Number，这种类型的operator+被这样声明：
const Number operator+(const Number& lhs,const Number& rhs);

这个函数的返回值是临时的，因为它没有被命名；它只是函数的返回值。必须为每次调用operator+构造和释放这个对象而付出代价。

通常我们不想付出这样的开销。对于这种函数，可以切换到operator=，而避免开销。不过对于大多数返回对象的函数来说，无法切换到不同的函数，从而没有办法避免构造和释放返回值。至少在概念上没有办法避免它。然而概念和现实之间又一个黑暗地带，叫做优化，有时能以某种方法编写返回对象的函数，以允许编译器优化临时对象。这些优化中，最常见和最有效的是返回值优化。

综上所述，临时对象是有开销的，所以应该尽可能地去除它们，然而更重要的是训练自己寻找可能建立临时对象的地方。在任何时候只要见到常量引用（reference-to-const）参数，就存在建立临时对象而绑定在参数上的可能性。在任何时候只要见到函数返回对象，就会有一个临时对象被建立（以后被释放）。学会寻找这些对象构造，就能显著地增强透过编译器表面动作而看到其背后开销的能力。

-------------------------------------------------
C++操作符重载与临时非堆变量的一次测试
出处

今天仔细看了一下以前当参考书翻的《Effective C++》和《More Effective C++》，着重看了里面讲述关于操作符重载的种种实做方法，看着很爽，就自己实际操作了一遍。编译器使用VC++.NET 7.1，因为这个编译器对C++标准的支持达到99%。现在把测试代码和输出贴出来，供同志们交流之用。
//CInt.h///////////////////////////////////
#include <iostream>
using namespace std;

class CInt
{
public:
CInt();
CInt(int i);
CInt(CInt& cint);
CInt(CInt* pcint);
CInt& operator =(const CInt& i);
CInt& operator =(int i);
void operator <<(char *str);
friend CInt operator +(const CInt& lhv, const CInt& rhv);
~CInt();
private:
int m_i;
};

//CInt.cpp///////////////////////////////////
#include "CInt.h"

CInt::CInt() :m_i(0)
{
cout<<"/n  CInt::CInt()  this="<<this;
}

CInt::CInt(int i) :m_i(i)
{
cout<<"/n  CInt::CInt(int i)  m_i="<<m_i<<"  this="<<this;
}

CInt::CInt(CInt &cint) :m_i(cint.m_i)
{
cout<<"/n  CInt::CInt(CInt &cint)  m_i="<<m_i<<"  cint.m_i="<<cint.m_i<<"  this="<<this<<"  &cint="<<&cint;
}

CInt::CInt(CInt *pcint) :m_i(pcint->m_i)
{
cout<<"/n  CInt::CInt(CInt *pcint)  m_i="<<m_i<<"  pcint->m_i="<<pcint->m_i<<"  this="<<this<<"  pcint="<<pcint;
}

CInt& CInt::operator =(const CInt &i)
{
cout<<"/n  CInt::operator =(CInt &i) this="<<this<<"  &i="<<&i;
m_i = i.m_i;
return (*this);
}

CInt& CInt::operator =(int i)
{
cout<<"/n  CInt::operator =(int i) this=his="<<this<<"  i="<<i;
m_i = i;
return (*this);
}

void CInt::operator <<(char *str)
{
cout<<"/n  CInt::operator <<(char *str) this="<<this<<"  m_i="<<m_i<<"  "<<str;
}

CInt operator +(const CInt& lhv, const CInt& rhv)
{
cout<<"/n  operator +(CInt& lhv, CInt& rhv)  lhv="<<&lhv<<"  rhv="<<&rhv;
return CInt(lhv.m_i+rhv.m_i);
}

CInt::~CInt()
{
cout<<"/n  CInt::~CInt()  this="<<this;
}

//main.cpp///////////////////////////////////
#include "CInt.h"

void Fun0(CInt i)
{
cout<<"/n Fun0(CInt i)  &i="<<&i;
}

void Fun1(CInt &i)
{
cout<<"/n Fun1(CInt &i)  &i="<<&i;
}

void Fun2(const CInt &i)
{
cout<<"/n Fun2(const CInt&i)  &i="<<&i;
}

void main()
{
cout<<"CInt i(2), temp(10);";
CInt i(2), temp(10);
cout<<"/nCInt j(i);";
CInt j(i);
cout<<"/nCInt k(&i);";
CInt k(&i);

cout<<"/nFun0(i);";
Fun0(i);
cout<<"/nFun1(i);";
Fun1(i);
cout<<"/nFun2(2);";
Fun2(2);

cout<<"/ni = temp;";
i = temp;
cout<<"/ni = 20;";
i = 20;
cout<<"/ni<</"mck/";";
i<<"mck";
cout<<"/ni = j+k;";
i = j+k;
cout<<"/ni = j+6;";
i = j+6;
cout<<"/ni = 5+j;";
i = 5+j;
cin.get();
}

/////////以下是输出/////////////////////////
CInt i(2), temp(10);
CInt::CInt(int i)  m_i=2  this=0012FEC4
CInt::CInt(int i)  m_i=10  this=0012FED4
CInt j(i);
CInt::CInt(CInt &cint)  m_i=2  cint.m_i=2  this=0012FEC8  &cint=0012FEC4
CInt k(&i);
CInt::CInt(CInt *pcint)  m_i=2  pcint->m_i=2  this=0012FED0  pcint=0012FEC4
Fun0(i);
CInt::CInt(CInt &cint)  m_i=2  cint.m_i=2  this=0012FEBC  &cint=0012FEC4
Fun0(CInt i)  &i=0012FEBC
CInt::~CInt()  this=0012FEBC
Fun1(i);
Fun1(CInt &i)  &i=0012FEC4
Fun2(2);
CInt::CInt(int i)  m_i=2  this=0012FECC
Fun2(const CInt&i)  &i=0012FECC
CInt::~CInt()  this=0012FECC
i = temp;
CInt::operator =(CInt &i) this=0012FEC4  &i=0012FED4
i = 20;
CInt::operator =(int i) this=his=0012FEC4  i=20
i<<"mck";
CInt::operator <<(char *str) this=0012FEC4  m_i=20  mck
i = j+k;
operator +(CInt& lhv, CInt& rhv)  lhv=0012FEC8  rhv=0012FED0
CInt::CInt(int i)  m_i=4  this=0012FECC
CInt::operator =(CInt &i) this=0012FEC4  &i=0012FECC
CInt::~CInt()  this=0012FECC
i = j+6;
CInt::CInt(int i)  m_i=6  this=0012FECC
operator +(CInt& lhv, CInt& rhv)  lhv=0012FEC8  rhv=0012FECC
CInt::CInt(int i)  m_i=8  this=0012FED8
CInt::operator =(CInt &i) this=0012FEC4  &i=0012FED8
CInt::~CInt()  this=0012FED8
CInt::~CInt()  this=0012FECC
i = 5+j;
CInt::CInt(int i)  m_i=5  this=0012FECC
operator +(CInt& lhv, CInt& rhv)  lhv=0012FECC  rhv=0012FEC8
CInt::CInt(int i)  m_i=7  this=0012FED8
CInt::operator =(CInt &i) this=0012FEC4  &i=0012FED8
CInt::~CInt()  this=0012FED8

/////////测试总结/////////////////////////
首先是各操作符的参数类型均设置成了const常类型，这一点在More Effective C++一书条款19中有明确的说明，这样做是为了使操作符能接受隐式的类型转换参数。测试语句是main()中的Fun2(2)调用，输出为：
CInt::CInt(int i)  m_i=2  this=0012FECC//隐式类型转换，由int 2构造临时对象
Fun2(const CInt&i)  &i=0012FECC//临时对象的引用传递给Fun2
CInt::~CInt()  this=0012FECC//Fun2结束，析构临时对象
根据这一点，在参数表中写上const将是一种是函数适用性提高的手段。
其次是operator + 的使用，这一点在Effctive C++条款19中有说明。若将该操作符声明为类的成员，则(CInt)i+(int)2的调用是正确的，而(int)2+(CInt)i的调用是错误的，这一点不满足内置类型int满足的交换率。因此操作符被声明为友元。测试语句是main()中的最后两句 i=j+6;i=5+j;输出为：
i = j+6;
CInt::CInt(int i)  m_i=6  this=0012FECC//隐式类型转换，由int 6构造临时对象
operator +(CInt& lhv, CInt& rhv)  lhv=0012FEC8  rhv=0012FECC//执行操作符制定的操作
CInt::CInt(int i)  m_i=8  this=0012FED8//为了返回结果而构造另外一个局部无名对象
CInt::operator =(CInt &i) this=0012FEC4  &i=0012FED8//返回结果复制给i，所以调用“=”操作符
CInt::~CInt()  this=0012FED8//释放局部无名对象
CInt::~CInt()  this=0012FECC//操作符调用结束，释放临时对象
i = 5+j;//同上