C++匿名对象
C++之匿名对象解析
我们知道在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!
construct用法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;<br>
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() 中的⽆名对象拷贝构造调⽤表达式处的临时对象
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论