c++ 临时对象

我们知道在C++的创建对象是一个费时，费空间的一个操作。有些固然是必不可少，但还有一些对象却在我们不知道的情况下被创建了。通常以下三种情况会产生临时对象：

1，以值的方式给函数传参；

2，类型转换；

3，函数需要返回一个对象时；

现在我们依次看这三种情况：

一，以值的方式给函数传参。

我们知道给函数传参有两种方式。1，按值传递；2，按引用传递。按值传递时，首先将需要传给函数的参数，调用拷贝构造函数创建一个副本，所有在函数里的操作都是针对这个副本的，也正是因为这个原因，在函数体里对该副本进行任何操作，都不会影响原参数。我们看以下例子：


/*-----------------------
Platform:WinXp + VC6
-----------------------*/
#include <stdio.h>
class CTemp
{
public:
    int a;
    int b;
public:
    CTemp(CTemp& t){ printf("Copy function!\n");a = t.a;b = t.b;};
    CTemp(int m = 0,int n = 0);
    virtual ~CTemp(){};
public:
    int GetSum(CTemp ts);
};
CTemp::CTemp(int m , int n)
{
    printf("Construct function!\n");
    a = m;b=n;
    printf("a = %d\n",a);
    printf("b = %d\n",b);
}
int CTemp::GetSum(CTemp ts)
{
    int tmp = ts.a + ts.b;
    ts.a = 1000;           //此时修改的是tm的一个副本
    
    return tmp;
}
//--------------Main函数-----------------
void main()
{
    CTemp tm(10,20);
    printf("Sum = %d \n",tm.GetSum(tm));
    printf("tm.a = %d \n",tm.a);
}

--------------------------------------------------------

Output:

Construct function!
a = 10
b = 20
Copy function!
Sum = 30
tm.a = 10

------------------------------------------------------

我们看到有调用了拷贝构造函数，这是tm在传给GetSum做参数时：

1，调用拷贝构造函数来创建一个副本为GetSum函数体内所用。

2，在GetSum函数体内对tm副本进行的修改并没有影响到tm本身。

解决办法：

针对第一种情况的解决办法是传入对象引用(记住：引用只是原对象的一个别名(Alias))，我们将GetSum代码修改如下：

int CTemp::GetSum(CTemp& ts)
{
    int tmp = ts.a + ts.b;
    ts.a = 1000;     //此时通过ts这个引用参考(refer to)对象本身
    return tmp;
}

----------------------------------------------------------

Output:

Construct function!
a = 10
b = 20
Sum = 30
tm.a = 1000

--------------------------------------------------------

可以通过输出看本，通过传递常量引用，减少了一次临时对象的创建。这个改动也许很小，但对多继承的对象来说在构建时要递归调用所有基类的构造函数，这对于性能来说是个很大的消耗，而且这种消耗通常来说是没有必要的。

二，类型转换生成的临时对象。

我们在做类型转换时，转换后的对象通常是一个临时对象。编译器为了通过编译会创建一起我们不易察觉的临时对象。再次修改如上main代码：


void main()
{
 CTemp tm(10,20),sum;
 sum = 1000;  //调用CTemp(int m = 0,int n = 0)构造函数
 printf("Sum = %d \n",tm.GetSum(sum));
}

-----------------------------------------------------------

Output:

Construct function!
a = 10
b = 20
Construct function!
a = 0
b = 0
Construct function!
a = 1000
b = 0
Sum = 1000

----------------------------------------------------------

main函数创建了两个对象，但输出却调用了三次构造函数，这是为什么呢？

关键在 sum = 1000;这段代码。本身1000和sum类型不符，但编译器为了通过编译以1000为参调用构造函数创建了一下临时对象。

解决办法：

我们对main函数中的代码稍作修改，将sum申明推迟到“=”号之前：

void main()
{
 CTemp tm(10,20);
 CTemp sum = 1000; 
 printf("Sum = %d \n",tm.GetSum(sum));
}

----------------------------------------------------------

Output:

Construct function!
a = 10
b = 20
Construct function!
a = 1000
b = 0
Sum = 1000

----------------------------------------------------------

只作了稍稍改动，就减少了一次临时对象的创建。

1，此时的“=”号由原本的赋值变为了构造。

2，对Sum的构造推迟了。当我们定义CTmep sum时，在main的栈中为sum对象创建了一个预留的空间。而我们用1000调用构造时，此时的构造是在为sum预留的空间中进行的。因此也减少了一次临时对象的创建。

三，函数返回一个对象。

当函数需要返回一个对象，他会在栈中创建一个临时对象，存储函数的返回值。看以下代码:


#include <stdio.h>
class CTemp
{
public:
    int a;
public:
    CTemp(CTemp& t) //Copy Ctor!
    { 
        printf("Copy Ctor!\n");
        a = t.a;
    };
    CTemp& operator=(CTemp& t) //Assignment Copy Ctor!
    {
        printf("Assignment Copy Ctor!\n");
        a = t.a;
        return *this;
    }
    CTemp(int m = 0);
    virtual ~CTemp(){};
};
CTemp::CTemp(int m) //Copy Ctor!
{
    printf("Construct function!\n");
    a = m;
    printf("a = %d\n",a);
}
CTemp Double(CTemp& ts)
{
    CTemp tmp;      //构建一个临时对象
    tmp.a = ts.a*2;
    return tmp;
    
}
//-------------Main函数-----------------
void main()
{
    CTemp tm(10),sum;
    printf("\n\n");

    sum = Double(tm);

    
    printf("\n\nsum.a = %d \n",sum.a);
}

---------------------------------------------------------

Output:

Construct function!
a = 10
Construct function!
a = 0

Construct function!
a = 0
Copy Ctor!
Assignment Copy Ctor!

sum.a = 20

--------------------------------------------------------

我特地加宽了语句:

sum = Double(tm);

这条语句竟生成了两个对象，Horrible! 我们现在将这条语句逐步分解一下：

1,我们显式创建一个tmp临时对象,

语句：CTemp tmp;

2,将temp对象返回，返回过程中调用Copy cotr创建一个返回对象,

语句：return tmp;

3,将返回结果通过调用赋值拷贝函数,赋给sum

语句: sum = 函数返回值;(该步并没有创建对象，只是给sum赋值)

tm.Double返回一个用拷贝构造函数生成的临时对象，并用该临时对象给sum赋值.

上面的第1步创建对象可以不用创建，我们可以直接对返回值进行操作，有些C++编译器中会有一种优化，叫做(NRV,named return value).不过本人使用的VC++6.0并没有这个启用这个优化。

第2步创建的返回对象是难以避免的，你或许想可以返回一个引用，但你别忘记了在函数里创建的局部对象，在返回时就被销毁了。这时若再引用该对象会产生未预期的行为。(C#中解决了这个问题)。

解决方法：

我们将对象直接操作(Manipulate)返回对象,再结合上面的减少临时对象的方法，将函数Double的代码，及main函数中的代码修改如下：

CTemp Double(CTemp& ts)
{
    return ts.a*2;
}
/*--------上面的代码相当于-------
CTemp _ret
void Double(CTemp& ts)
{
    _ret.a = ts.a*2;
}
---------------*/


//---------Main函数-----------
void main()
{
    CTemp tm(10);
    printf("\n\n");

CTemp sum = Double(tm);
    
    printf("\n\nsum.a = %d \n",sum.a);
}

--------------------------------------------------------

Output:

Construct function!
a = 10

Construct function!
a = 20

sum.a = 20

-------------------------------------------------------

发现减少了一次构造函数调用(tmp)，一次拷贝构造函数(tmp拷贝给返回对象)调用和一次赋值拷贝函数调用.(Assignment Copy Ctor),这是因为：

返回对象直接使用为sum预留的空间，所以减少了返回临时对象的生成——返回对象即是sum，返回对象的创建即是sum对象的创建.多么精妙!

************************************************************************************

C++中真正的临时对象是看不见的，它们不出现在你的源代码中，临时对象的产生在如下几个时刻:

1.       用构造函数作为隐式类型转换函数时，会创建临时对象。

例：

class Integer

{

public:

Integer(int i)

:m_val(i)

{}

~Integer()

{}

private:

int   m_val;

};

void Calculate(Integer itgr)

{

// do something

}

那么语句：  int  i = 10;

Calculate(i);

会产生一个临时对象，作为实参传递到Calculate 函数中。

2.       建立一个没有命名的非堆（non-heap）对象，也就是无名对象时，会产生临时对象。

如：

Integer& iref = Integer(5);           //用无名临时对象初始化一个引用,等价于

//Integer iref(5);

Integer  itgr = Integer(5);           //用一个无名临时对象拷贝构造另一个对象

按理说，C++应先构造一个无名的临时对象，再用它来拷贝构造itgr，由于

该临时对象拷贝构造 itgr 后，就失去了任何作用，所以对于这种类型(只起拷贝构造另一个对象的作用)的临时对象，c++特别将其看做: Integer itgr(5); 即直接以相同参数构造目标对象，省略了创建临时对象这一步。

Calculate( Integer(5) );                       //无名临时对象作为实参传递给形参,函数调

//用表达式结束后，临时对象生命期结束，被//析构.

3.       函数返回一个对象值时，会产生临时对象，函数中的返回值会以值拷贝的形式拷贝到被调函数栈中的一个临时对象。

如：

Integer Func()

{

Integer itgr;

return itgr;

}

void main()

{

Integer in;

in = Func();

}

表达式 Func() 处创建了一个临时对象，用来存储Func() 函数中返回的对象，临时对象由 Func()中返回的 itgr 对象拷贝构造(值传递)，临时对象赋值给 in后，赋值表达式结束，临时对象被析构。见下图：

看看如下语句：

Integer& iRef = Func();

该语句用一个临时对象去初始化iRef 引用，一旦该表达式执行结束，临时对象的生命周期结束，便被结束，iRef引用的尸体已经不存在，接下来任何对 iRef 的操作都是错误的。

下面，来看看实际的测试结果，代码如下：

class VECTOR3

{

public:

VECTOR3()

:x(0.0f),y(0.0f),z(0.0f)

{

std::cout<<"VECTOR3 Default Constructor "

<<std::setiosflags(std::ios_base::hex)<<this

<<std::endl;

}

VECTOR3(float fx, float fy, float fz)

:x(0.0f),y(0.0f),z(0.0f)

{

std::cout<<"VECTOR3 Parameter Constructor "

<<std::setiosflags(std::ios_base::hex)<<this

<<std::endl;

}

VECTOR3(const VECTOR3& rht)

:x(rht.x), y(rht.y), z(rht.z)

{

std::cout<<"VECTOR3 Copy Constructor "

<<std::setiosflags(std::ios_base::hex)<<this

<<" from rht : "

<<std::setiosflags(std::ios_base::hex)<<&rht

<<std::endl;

}

~VECTOR3()

{

std::cout<<"VECTOR3 Destructor "

<<std::setiosflags(std::ios_base::hex)<<this

<<std::endl;

}

VECTOR3& operator = (const VECTOR3& rht)

{

if( &rht == this )

return *this;

x = rht.x;

y = rht.y;

z = rht.z;

std::cout<<"VECTOR3 operator = left oper : "

<<std::setiosflags(std::ios_base::hex)<<this

<<" right oper : "

<<std::setiosflags(std::ios_base::hex)<<&rht

<<std::endl;

return *this;

}

private:

float x;

float y;

float z;

};

VECTOR3 Func1()

{

return VECTOR3(1.0f, 1.0f, 1.0f);

}

VECTOR3 Func2()

{

VECTOR3 ret;

ret.x = 2.0f;

ret.y = 2.0f;

ret.z = 2.0f;

return ret;

}

void main()

{

VECTOR3 v1 = Func1();

v1 = Func1();

VECTOR3 v2 = Func2();

VECTOR3 v3;

v3 = Func2();

}

分析：

<1>.

VECTOR3 v1 = Func1();

该语句的执行过程本该是：

1>. 在 Func1() 中构造一个无名对象

2>. 由 Func1() 中的无名对象拷贝构造调用表达式处的临时对象

3>. 再由临时对象拷贝构造v1

4>. Func1() 返回，析构无名对象

5>. 整个语句结束，析构临时对象

但是c++ 会优化上述过程，省略了 1>. 2>. 处的临时对象创建，直接以

1.0f, 1.0f, 1.0f 为参数构造v1，这样只会有一次构造函数的调用。结果

如图：

<2>.

v1 = Func1();

该语句的执行过程本该是：

1>. 在 Func1() 中构造一个无名对象

2>. 由 Func1() 中的无名对象拷贝构造调用表达式处的临时对象

3>. 再由临时对象赋值给v1 (赋值运算符)

4>. Func1() 返回，析构无名对象

5>. 整个语句结束，析构临时对象

但是c++ 会优化上述过程，省略了 1>. 处的无名临时对象创建，直接以

1.0f, 1.0f, 1.0f 为参数构造调用表达式处的临时对象，因为是赋值，所以这个临时对象是无法被优化的，赋值完毕后，表达式结束，临时对象被析构。结果如图：

<3>.

VECTOR3 v2 = Func2();

该语句的执行过程本该是：

1>. Func2() 中的 ret 拷贝构造调用表达式处的临时对象

2>. 该临时对象拷贝构造v2

3>. 析构临时对象

但是c++ 会优化上述过程，省略了创建临时对象这一步，直接由ret拷贝

构造v2，就一次拷贝构造函数的代价。

结果如图：

<4>.

VECTOR3 v3;

v3 = Func2();

执行过程如下：

1>. 构造v3

2>. 进入Func2()，构造ret

3>. 返回ret，用ret拷贝构造到调用表达式处的临时对象

4>. Func2()结束，ret被析构

5>. 临时对象赋值给v3

6>. 赋值表达式结束，析构临时对象

结果如图：

综上所述，可得如下结论：

<1>. 在使用一个临时对象( 可能是无名对象 或者 返回对象值时 ) 创建构造另一个对象的过程的中，c++会优化掉该临时对象的产生，直接以相同参数调用相关构造函数构或者 直接调用拷贝构造函数 到 目标对象.

<2>. 若不是对象创建，而是对象赋值，则在赋值表达式的右值处的临时对象

创建不能省略，临时对象赋值给左值后，表达式结束，临时对象被析构

c++ 临时对象

时间： 2024-11-08 23:57:56

c++ 临时对象的相关文章

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

C++标准的规定:非常量的引用不能指向临时对象: 为了防止给常量或临时变量(只有瞬间的生命周期)赋值(易产生bug),只许使用const引用之. 下面的内容转自: http://blog.csdn.net/liuxialong/article/details/6539717 概括一下: 不能把临时对象作为实参传给非const引用. 例如: void conv(string &str) { } int main() { conv("dasd"); // 这里错了,编译器自动生成一

一个函数返回临时对象引起的编译器优化问题

我们都知道,如果在一个函数调用另一个函数,假设是 main 函数调用 fun 函数,这个 fun 函数返回一个临时类类型变量,那么这个时候编译器就会在 main 函数申请一个空间并生成一个临时对象,通过拷贝构造函数将 fun 返回的临时变量的值拷贝到这个临时对象.我们看如下的代码: #include <iostream> #include <cstring> using namespace std; class Matrix { public: explicit Matrix(do

C++临时对象减少的方法

C++临时对象产生的场景: 1. 值传递   2. 函数返回   3. 后置++ 等 减少临时对象产生的方法: 1. 使用引用或指针传递 2. 避免隐式类型转换 3. 使用 += 代替 + string x = a + b; // 这里会产生保存a+b值的临时对象 string x(a); x += b; // 这样就不会产生临时对象 4. 使用前置++代替后置++ 前置++的定义: type operator++(); 后置++的定义: const type operator++(int);

对象追踪、临时对象追踪、绝对坐标与相对坐标

1.对象追踪 快捷键SE 若所画的图形不是在水平或垂直方向上的则按极坐标的方法输入 如下图 临时对象追踪 快捷键  键盘上的ctrl+鼠标右键 与对象追踪差不多只是使用时需要点击起点接下来的步骤与使用对象追踪时的一样 2.绝对坐标 就是以坐标系为原点建立的直角坐标系 输入时按直角坐标系的方法输入(x,y) 如下图 这样输入得到的是一条线段的长度 如果不输入0,0,只输入5,10则就是如下图 相对坐标就是以上一个点为原点建立直角坐标系 输入时在输入的坐标前面加上@然后在输入坐标 当在输入时软件发现

C++临时对象销毁时间

下面这段代码会输出什么? [cpp] view plaincopy const char* p = string("hello temprary string").c_str(); cout << p; 下面这段代码运行之后会怎样? [cpp] view plaincopy #include <vector> class Foo { public: Foo() { _p = new char[32]; } ~Foo() { delete _p; } privat

转：C++中临时对象及返回值优化

http://www.cnblogs.com/xkfz007/articles/2506022.html 什么是临时对象? C++真正的临时对象是不可见的匿名对象,不会出现在你的源码中,但是程序在运行时确实生成了这样的对象. 通常出现在以下两种情况: (1)为了使函数调用成功而进行隐式类型转换的时候. 传递某对象给一个函数,而其类型与函数的形参类型不同时,如果可以通过隐式转化的话可以使函数调用成功,那么此时会通过构造函数生成一个临时对象,当函数返回时临时对象即自动销毁.如下例: //计算字符ch

STL——临时对象的产生与运用

所谓临时对象,就是一种无名对象.它的出现如果不在程序员的预期之下(例如任何pass by value操作都会引发copy操作,于是形成一个临时对象),往往造成效率上的负担.但有时候刻意制造一些临时对象,却又是使程序干净清爽的技巧.刻意制造临时对象的方法是,在型别名称之后直接加一对小括号,并可指定初值,例如Shape(3,5)或int(8),其意义相当于调用相应的constructor且不指定对象名称.STL最常将此技巧应用于仿函数(functor)与算法的搭配上,例如: #include<ios

C++11系列之——临时对象分析

/*C++中返回一个对象时的实现及传说中的右值——临时对象*/ 如下代码: 1 /**********************************************/ 2 class CStudent; 3 CStudent GetStudent() 4 { 5 CStudent loc_stu; 6 return loc_stu; 7 } 8 9 int main() 10 { 11 CStudent stu = GetStudent(); 12 } 13 /************

关于C++临时对象的一道题目

下面的代码输出什么?为什么? class Test { int m_i; int m_j; public: Test(int v) { cout<<"Test(int v)"<<endl; } ~Test() { cout<<"~Test()"<<endl; } }; Test Play(Test t) { return t; } int main() { Test t = Play(5); } 用编译器检测   最后

C++临时对象以及针对其进行的优化

C++临时对象以及针对其进行的优化 C++中真正的临时对象是看不见的,它们不出现在你的源代码中. 那么什么时候回产生临时对象呢?主要是三个时刻: 产生临时对象的三个时刻: 用构造函数作为隐式类型转换函数时,会创建临时对象 看个例子: 在主函数中,我们直接用一个整型量10对对象ca进行初始化,这个时候 http://pic.cnhubei.com/space.php?uid=1132&do=album&id=802337http://pic.cnhubei.com/space.php?uid