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

  1,以值的方式给函数传参;
  2,类型转换;
  3,函数需要返回一个对象时;
 
现在我们依次看这三种情况:
 
  一,以值的方式给函数传参。
 
  我们知道给函数传参有两种方式。1,按值传递;2,按引用传递。按值传递时,首先将需要传给函数的参数,调用拷贝构造函数创建一个副本,所有在函数里的操作都是针对这个副本的,也正是因为这个原因,在函数体里对该副本进行任何操作,都不会影响原参数。我们看以下例子:
 
#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>. 若不是对象创建,而是对象赋值,则在赋值表达式的右值处的临时对象

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

补充知识点:匿名对象转正!

///**********************************************
/// @file VECTOR.cc
/// @author alex(AlexCthon@qq.com)
/// @date 2018-06-10 20:38:41
///**********************************************/ #include <iostream>
using namespace std; class VECTOR
{
public:
VECTOR(){
_ix=0;_iy=0;
}
VECTOR(int ix,int iy)
:_ix(ix)
,_iy(iy)
{
cout << "VECTOR(int,int) " << _ix <<","<< _iy << endl;
}
VECTOR(const VECTOR &rhs)
:_ix(rhs._ix)
,_iy(rhs._iy)
{
} VECTOR & operator =(const VECTOR &rhs)
{
_ix = rhs._ix;
_iy = rhs._iy;
return *this;
} private:
int _ix;
int _iy;
};
//g函数:返回一个元素
//结论1:函数的返回值是一个元素(复杂类型的),返回的是一个新的匿名对象(所以会调用匿名对象类的copy构造函数)
//结论2:有关匿名对象的去和留。
//    如果用匿名兑现给初始化,另一个同类型的对象,匿名对象专程有名对象
//    如果用匿名对象赋值给另一个同类型的对象,匿名对象就马上被析构掉
//
VECTOR p()
{
VECTOR A(21,21);
return A;
};
void obj1()
{   VECTOR a=p();//用匿名对象初始化m,此时c++编译器,直接把匿名对象专程m(扶正),从匿名专程有名字了。
    //匿名对象,被扶正,不会被析构掉
}
void obj2()
{   VECTOR a(1,2);
  a=p();//用匿名对象赋值给另一个同类型的对象,匿名对象就马上被析构掉
}
int main()
{
obj1();
   obj2();
return 0;
}

  

C++之匿名对象解析的更多相关文章

  1. C#关于反序列化实例时,接收实体字段少于或大于原实体对象 解析测试

    在项目中总会用到son解析,比如RabbitMQ中使用json串解析,比如发过来的实体对象有50个字段,而实际只需要用到里面的几个字段,这时我们创建实体时,只需要创建需要的几个字段即可. 测试实例,首 ...

  2. Asp.Net WebApi核心对象解析(下篇)

    在接着写Asp.Net WebApi核心对象解析(下篇)之前,还是一如既往的扯扯淡,元旦刚过,整个人还是处于晕的状态,一大早就来处理系统BUG,简直是坑爹(好在没让我元旦赶过来该BUG),队友挖的坑, ...

  3. 当类型为dynamic的视图模型遭遇匿名对象

    当年在ASP.NET MVC 1.0时代我提到,在开发时最好将视图的Model定制为强类型的,这样可以充分利用静态检查功能进行排错.不过有人指出,这么做虽然易于静态检查,但是定义强类型的Model类型 ...

  4. 匿名对象 构造方法 重载 构造代码块 this 关键字

    一.匿名对象 1.匿名对象 :没有名字对象 2.匿名对象的使用注意点: 1.我们一般不会用匿名对象给属性赋值,无法获取属性值. 2.匿名对象永远都不可能事一个对象. 3.匿名对象的好处 : 书写简单. ...

  5. C# 匿名对象随笔

      最新更新请访问: http://denghejun.github.io   C#中匿名对象的一般写法是这样的: object o=new {Name="TestName"}; ...

  6. MongoDB学习笔记~以匿名对象做为查询参数,方便查询子对象

    回到目录 对于MongoDB的封装还在继续,对于不断追求简单的编程还在继续,对于喜欢代码的那么感觉,还在继续... 当你的mongo数据表里有子对象时,尤其是列表对象时,使用官方的驱动很是不爽,要记得 ...

  7. dynamic与匿名对象

    用dynamic接收匿名对象很方便,因为不需要去定义model了,但是也有一个弊端,就是匿名对象的作用范围是internal的,也就是只能存在于当前程序域,所以用dynimic跨程序域去接收一个匿名对 ...

  8. 构造 & 析构 & 匿名对象‍

    ‍以前仅知道创建对象,但对匿名对象的了解基本为0. 通过阅读google chromium源代码 中关于 log 的使用,查阅相关资料,了解了一下匿名对象,予以记录. 什么是匿名对象‍ 匿名对象可以理 ...

  9. java匿名类和匿名对象及this的其他用法

    /* 匿名内部类:就是内部类的简写格式. 必须前提:内部类必须继承或者实现一个类或者接口. 匿名内部类其实就是一个匿名 子类对象. 格式:new 父类对象 or 接口(){ 子类内容:(覆盖父类的, ...

随机推荐

  1. CMake使用hellocmake&&make的使用

    2016-12-11   20:38:32 已经知道cmake这个东西很长的时间了,一直没有试验过,知道它是一个编译工具,在opencv和Linux下都有makefile的内容.感觉现在对源码的编译有 ...

  2. 网站无法显示logo?

    那是因为你没有配置favicon.ico,每个网站根目录都会有一个favicon.ico,因为每个服务器都会请求根目录下的它.

  3. 合并SO为单独交货单

    本场景为单步交货     为客户建立专用的route.     增加一个pull rule         在做订单的时候,为订单行选择 上面建立好的route,     连续建立了 2个 订单 SO ...

  4. was系统错误日志大量出现标识符缺失

    原创作品.出自 "深蓝的blog" 博客,深蓝的blog:http://blog.csdn.net/huangyanlong/article/details/46909941 近日 ...

  5. H5实现多图片预览上传,可点击可拖拽控件介绍

    版权声明:欢迎转载,请注明出处:http://blog.csdn.net/weixin_36380516 在做图片上传时发现一个蛮好用的控件,支持多张图片同时上传,可以点击选择图片,也可以将图片拖拽到 ...

  6. teradata培训文档 相关索引

    teradata培训文档 http://wenku.baidu.com/view/ec44c201cc175527072208ba.html Teradata 和Greenplum 的讨论 http: ...

  7. js thiskeyword

    相信大家都接触过this了,那么 this究竟是什么意思呢?看其字面意思就是个代词.指代其它的一些东西. 那么我们在程序其中,事实上也是一样.this也是个代词. 比方我们在java其中,this的k ...

  8. EasyPusher实现Android手机屏幕桌面直播,实时推送操作画面,用于手游直播等应用

    本文转自EasyDarwin开源团队成员John的博客:http://blog.csdn.net/jyt0551/article/details/52651194 由于Android 5.0提供了捕获 ...

  9. Möbius strip

    en.wikipedia.org/wiki/Möbius_strip http://mechproto.olin.edu/final_projects/average_jo.html Fabricat ...

  10. C++继承类同名数据成员被隐藏,其实都在内存里,转换后都可以被使用

    #include "stdafx.h" class A { public: int i; A() { i=; } }; class B: public A { public: in ...