思享工具箱

C++之匿名对象解析

摘要：
我们知道在C++的创建对象是一个费时，费空间的一个操作。2，在GetSum函数体内对tm副本进行的修改并没有影响到tm本身。解决办法：针对第一种情况的解决办法是传入对象引用，我们将GetSum代码修改如下：intCTemp::GetSum{inttmp=ts.a+ts.b;ts.a=1000;//此时通过ts这个引用参考对象本身returntmp;}----------------------------------------------------------Output:Constructfunction!2，对Sum的构造推迟了。当我们定义CTmepsum时，在main的栈中为sum对象创建了一个预留的空间。因此也减少了一次临时对象的创建。

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

1，以值的方式给函数传参；
2，类型转换；
3，函数需要返回一个对象时；
现在我们依次看这三种情况：
一，以值的方式给函数传参。
我们知道给函数传参有两种方式。1，按值传递；2，按引用传递。按值传递时，首先将需要传给函数的参数，调用拷贝构造函数创建一个副本，所有在函数里的操作都是针对这个副本的，也正是因为这个原因，在函数体里对该副本进行任何操作，都不会影响原参数。我们看以下例子：
#include <stdio.h>
class CTemp
{
public:
    int a;
    int b;
public:
    CTemp(CTemp& t){ printf("Copy function!
");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!
");
    a = m;b=n;
    printf("a = %d
",a);
    printf("b = %d
",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 
",tm.GetSum(tm));
    printf("tm.a = %d 
",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 
",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 
",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!
");
        a = t.a;
    };
    CTemp& operator=(CTemp& t) //Assignment Copy Ctor!
    {
        printf("Assignment Copy Ctor!
");
        a = t.a;
        return *this;
    }
    CTemp(int m = 0);
    virtual ~CTemp(){};
};
CTemp::CTemp(int m) //Copy Ctor!
{
    printf("Construct function!
");
    a = m;
    printf("a = %d
",a);
}
CTemp Double(CTemp& ts)
{
    CTemp tmp;      //构建一个临时对象
    tmp.a = ts.a*2;
    return tmp;
    
}
//-------------Main函数-----------------
void main()
{
    CTemp tm(10),sum;
    printf("

");

    sum = Double(tm);

    
    printf("

sum.a = %d 
",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("

");

    CTemp sum = Double(tm);
    
    printf("

sum.a = %d 
",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
}

那么语句：inti = 10;

Calculate(i);

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

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

如：

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

//Integer iref(5);

Integeritgr = 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后，赋值表达式结束，临时对象被析构。见下图：

C++之匿名对象解析第1张

看看如下语句：

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，这样只会有一次构造函数的调用。结果

如图：

C++之匿名对象解析第2张

<2>.

v1=Func1();

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

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

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

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

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

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

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

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

C++之匿名对象解析第3张

<3>.

VECTOR3v2=Func2();

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

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

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

3>.析构临时对象

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

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

结果如图：

C++之匿名对象解析第4张

<4>.

VECTOR3v3;

v3=Func2();

执行过程如下：

1>.构造v3

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

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

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

5>.临时对象赋值给v3

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

结果如图：

C++之匿名对象解析第5张

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

<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;
}

标签：#printf#函数调用#匿名函数#赋值语句#解析函数 | 浏览：138 | 发布日期：

免责声明：文章转载自《C++之匿名对象解析》仅用于学习参考。如对内容有疑问，请及时联系本站处理。

上篇关于《国际经济学》若干问题的思考《三》把网页发送到桌面代码下篇

宿迁高防，2C2G15M，22元/月；香港BGP，2C5G5M，25元/月 雨云优惠码：MjYwNzM=

相关文章

ES6规范

一、简介 js由三部分组成：ES+DOM（文档对象模型）+ BOM（浏览器对象模型） ES作为核心，是一套标准，规范了语言的组成部分：语法、类型、语句、关键字、保留字。定义了数据结构和语法，定义了函数和对象的实现，包括原型链和作用域链的机制和实现。 JavaScript 的核心 ECMAScript 描述了该语言的语法和基本对象； DOM 描述了处理网页内...

GDB和WinDbg中调用函数

GDB： 特别简单，直接写调用式子即可，如下图的p word.c_str()，其中word的类型是std::string WinDbg：目前都说是.call命令，说实话我宁愿不用。。。见： http://cfc.kizzx2.com/index.php/tutorial-using-windbg-to-call-arbitrary-functions-w...

React入门

1.JSX语法 JSX语法就是，可以在js文件中插入html片段，是react自创的一种语法 JSX语法会被Babel等转码工具进行转码，得到正常的js代码再执行。 注意： 1.所有的html标签必须是闭合的 2.再jsx语法中，只能有一个根标签 2.组件 组件是react中核心概念，一个网页，可以被拆分成一个个组件。 react中自定义组件四个步骤： /...

静态方法、类方法、实例方法

static 修饰局部变量：延长布局变量的生命周期static 修饰全局变量：当前变量只能在当前文件中使用static 修饰函数： 函数只能在当前文件中使用 静态：与程序的生命周期相同的数据结构，从程序启动时就存在，当程序停止时才被销毁。 静态变量：分为局部静态变量和全局静态变量两种，必须使用 “static” 关键字修饰。 局部静态变量： 一般定...

wireshark源码分析二

一、源代码结构 在wireshark源代码根目录下，可以看到以下子目录： 1）物理结构     其中，epan文件夹负责所有网络协议识别工作，plugins里面存放了wireshark所有插件，gtk文件夹里面是wireshark的界面部分代码，其余文件夹没有单独研究。 2）逻辑结构     下图给出了Ethereal功能模块：    a) GTK1/2...

在webView 中使用JS 调用 Android / IOS的函数 Function

最近做一个项目，混合了NativeCode 和 HTML，为了便于JS 调用App的一些方法，统一封装一个Js方法，记录如下 Android 端首先要再WebView中允许JS的调用 WebView myWebView = (WebView) findViewById(R.id.webview); WebSettings webSettings = myW...

最新文章

随机推荐

思享工具箱导航