目录
- 1.以值传递的方式给函数传参
- 1.1以值传递的方式给函数传参
- 1.2 解决方案—以引用的方式传参
- 2.类型转换生成的临时对象
- 3.函数返回一个对象
- 3.1 需要构造临时对象的例子--例1
- 3.2 需要构造临时对象的例子--例2
- 3.3 返回值优化
C++中三种常见的临时对象创建的情况：
（1）以值传递的方式给函数传参；
（2）类型转换；
（3）函数需要返回对象时。
1.以值传递的方式给函数传参
1.1以值传递的方式给函数传参
按值传递时，传给函数的参数会调用拷贝构造函数创建一个临时对象，所有在函数体内的操作都是在这个临时对象上的操作，所以函数体内对该临时对象进行任何操作都不会影响原参数。当临时对象销毁时，即函数形参销毁，就会调用该临时对象的析构函数。无论是调用拷贝构造函数还是析构函数，都是额外的开销。
1.2 解决方案—以引用的方式传参
如何避免这种临时对象的产生呢？
只要把以值传递的方式修改为以引用传递的方式即可。这样既不会调用拷贝构造函数，也不会多调用一次临时对象的析构函数。因此能够减少额外不必要的开销。引用是对象本身，只是对象的一个别名。
2.类型转换生成的临时对象
class TempObj
{
public:
TempObj(int a = 10, int b=20)
{
_capacity = a;
_size = b;
cout << "有参构造" << endl;
cout << "_capacity=" << _capacity << ",_size=" << _size << endl;
}
TempObj(const TempObj& p)
{
cout << "拷贝构造" << endl;
}
~Te编程客栈mpObj()
{
cout << "析构函数" << endl;
}
int GetSum(TempObj& p)
{
int sum = p._capacity + p._size;
return sum;
}
public:
int _capacity;
int _size;
};
int main()
{
TempObj m1(28,29), m2;
m2 = 30;
cout << "sum=" << m1.GetSum(m2) << endl;
}
运行结果如下：
main函数创建了两个对象m1和m2，但输出却调用了三次构造函数。关键在于m2=30;30和m2的类型不同，但编译器为了通过编译以30为参数调用构造函数创建了一个临时对象。
解决办法如下及运行结果如下：
此时，“=”号由原本的赋值变成了构造。对m2的构造推迟了，当定义TempObj m2时，在main的栈中为m2对象创建了一个预留空间，而我们用30调用构造函数时，此时的构造函数是在m2预留的空间中进行的，因此减少了一次临时对象的创建。
3.函数返回一个对象
一个函数若直接返回类对象，一般会生成临时类对象变量，需多次调用拷贝构造函数（copy constructor）造成效率低下。
3.1 需要构造临时对象的例子--例1
需要构造临时对象的一个典型的情况就是我们需要把函数的返回值赋给一个已经存在的对象a，在这种情况下之所以不能直接使用的a的地址来存放函数f()的返回值。因为对象a现在里面已经有一些数据了，所以先要把对象a中的数据释放掉，然后才能去接受新的数据。这种先释放然后再拷贝的行为就是在赋值运算符的重载里面实现的。
在整个过程中，f()的调用者必须要先提供一个存放函数返回值的临时对象的地址，然后等f()返回之后，这个临时对象中存放的就是函数返回的对象。再通过移动的赋值将临时对象的值赋给a。如下图所示。
class TempObj
{
public:
TempObj()
{
cout << "无参构造函数" << endl;
std::cout << "Constructor on addr:" << static_cast<const void*>(this) << std::endl;
}
TempObj(const TempObj& p)
{
cout << "拷贝构造函数" << endl;
std::cout << "Copy constructor, this addr:" << static_cast<const void*>(this) << std::endl;
}
//赋值运算符重载
TempObj& operator=(const TempObj& p)
{
cout << "operator=(TempObj& to)" << endl;
if (this != &p)
{
//_capacity = p._capacity;
}
std::cout << "Move constructor, this addr:" << static_cast<const void*>(this) << std::endl;
return *this;
}
~TempObj()
{
cout << "析构函数" << endl;
}
};
TempObj GetObject()
{
std::cout << ">>>Enter GetObject..." << std::endl;
TempObj tmp;
return tmp;
}
int main()
{
TempObj m1;
m1 = GetObject();
std::cout << "<<<Leav编程客栈e GetObject..." << std::endl;
return 0;
}
运行结果如下：
首先，我们构造了一个对象m1,m1的地址就是00000049B02FFAA4，之后调用函数GetObject()，并把函数GetObject()的返回值赋值给M1。从运行结果可知，在GetObject()函数内部构造了一个新的对象即临时对象，地址为00000049B02FFB84。这个临时对象的空间是由函数GetObject()的调用者main函数提供的。等GetObject()调用结束，会调用赋值操作符的重载函数，将临时的对象赋值给m1。
3.2 需要构造临时对象的例子--例2
用图将该情况画出来，如下图所示：
tmp1和tmp2都是处于函数GetObject()开辟的栈帧上面，第一步是将需要返回的对象，通过拷贝构造函数构造到函数GetObject()的调用者提供的存放返回值的空间上去，即(ret)的位置。第二步是调用赋值将该临时赋值给m1。
代码如下：
class TempObj
{
public:
TempObj()
{
cout << "无参构造函数" << endl;
std::cout << "Constructor on addr:" << static_cast<const void*>(this) << std::endl;
}
TempObj(const TempObj& p)
{
cout << "拷贝构造函数" << endl;
std::cout << "Copy constructor, this addr:" << static_cast<const void*>(this) << std::endl;
}
//赋值运算符重载
TempObj& operator=(const TempObj& p)
{
cout << "operator=(TempObj& to)" << endl;
if (this != &p)
{
//_capacity = p._capacity;
}
std::cout << "Move constructor, this addr:" << static_cast<const void*>(this) << std::endl;
return *this;
}
~TempObj()
{
cout << "析构函数" << endl;
}
};
TempObj GetObject(int i)
{
std::cout << ">>>Enter GetObject..." << std::endl;
TempObj tmp1, tmp2;
if (i > 0)
return tmp1;
else
return tmp2;
}
int main()
{
TempObj m1;
m1 = GetObject(1);
std::cout << "<<<Leave GetObject..." << std::endl;
return 0;
}
运行结果如下：
首先我们构造一个m1，m1的地址为：000000CC1035FA54；然后进入到函数GetObject()，该函数中会构造两个对象tmp1和tmp2，tmp1的地址为：000000CC1035F8F4，tmp2的地址为：000000CC1035F914。根据输入决定哪个对象返回作为结果，然后将该结果赋值给m1。之后，调用了拷贝构造函数，这里出现了地址：000000CC1035FB34，该地址对应的就是临时对象，这个临时对象的地址是由函数GetObject()的调用者main函数所提供的，这个地址位于main函数开辟的栈帧上，可以看到该地址和m1的地址离的比较近。
根据输入的情况，我们把tmp1和tmp2中的1个通过拷贝构造函数构造出来，返回的结果通过赋值重载函数赋值到m1上，地址为：000000CC1035FA54。
3.3 返回值优化
上图中所说的优化即是指C++11以及之后的C++www.devze.com14、17标准均提出一项编译优化技术：复制省略（copy elision，也称复制消除），这项优化技术的中心思想是：一个函数若直接返回类对象，一般会生成临时类对象变量，需多次调用拷贝构造函数（copy constructor）造成效率低下，编译器对此优化，省略其中的拷贝构造环节，达到提升效率的目的。
class TempObj
{
public:
TempObj()
{
cout << "无参构造函数" << endl;
std::cout << "Constructor on addr:" << static_cast<const void*>(this) << std::endl;
}
TempObj(const TempObj& p)
{
cout << "拷贝构造函数" << endl;
std::cout << "Copy constructor, this addr:" << static_cast<const void*>(this) << std::endl;
}
//赋值运算符重载
TempObj& operator=(const TempObj& p)
{
cout << "operator=(TempObj& to)" << endl;
if (this != &p)
{
//_capacity = p._capacity;
}
std::cout << "Move constructor, this addr:" << static_cast<const void*>(this) << std::endl;
return *this;
}
~TempObj()
{
cout << "析构函数" << endl;
}
void Print(const char* pre)
{
std::cout << pre << "addr"
<< static_cast<const void*>(this) << std::endl;
}
};
TempObj GetObject()
{
std::cout << ">>>Enter GetObject..." << std::endl;
TempObj tmp;
returnphp tmp;
}
int main()
{
TempObj m1 = GetObject();
std::cout << "<<<Leave GetObject..." << std::endl;
m1.Print("Variable m1:");
return 0;
}
运行结果：
在上述代码追踪构造函数和拷贝构造函数的调用，以及构造所php发生的地址，以及提供一个打印函数，来打印某一个m1对象的地址。
通过GetObject()函数构造一个m1对象，并打印m1的地址。通过程序运行的结果可以发现，当我们进入到GetObject()函数时，首先构造了一个TempObj的对象tmp，我们会发现这里tmp对象所使用的地址就是最后对象m1的地址。也就是说在这整个过程里面，我们并没有构造一个另外的tmp对象，而是直接使用的是需要返回的m1的地址。整个过程中，并没有调用拷贝构造函数。这种优化就叫Copy elision。
这种情况是直接使用函数的返回值去构造一个新的对象的情况，这种情况下是不需要临时对象的，因为有新的对象的地址，我们可以直接使用这个地址来存放这个函数所需要返回的对象。
这种优化不适用的情况
class TempObj
{
public:
TempObj()
{
cout << "无参构造函数" << endl;
std::cout << "Constructor on addr:" << static_cast<const void*>(this) << std::endl;
}
TempObj(const TempObj& p)
{
cout << "拷贝构造函数" << endl;
std::cout << "Copy constructor, this addr:" << static_cast<const void*>(this) << std::endl;
}
//赋值运算符重载
TempObj& operator=(const TempObj& p)
{
cout << "operator=(TempObj& to)" << endl;
if (this != &p)
{
//_capacity = p._capacity;
}
std::cout << "Move constructor, this addr:" << static_cast<const void*>(this) << std::endl;
return *this;
}
~TempObj()
{
cout << "析构函数" << endl;
}
void Print(const char* pre)
{
std::cout << pre << "addr"
<< static_cast<const void*>(this) << std::endl;
}
};
TempObj GetObject(int i)
{
std::cout << ">>>Enter GetObject..." << std::endl;
TempObj tmp1, tmp2;
if (i > 0)
return tmp1;
else
return tmp2;
}
int main()
{
TempObj m1 = GetObject(1);
std::cout << "<<<Leave GetObject..." << std::endl;
m1.Print("Variable m1:");
return 0;
}
运行结果：
以上就是C++中产生临时对象的情况及其解决方案的详细内容，更多关于C++产生临时对象的资料请关注编程客栈(www.devze.com)其它相关文章！
加载中,请稍侯......
精彩评论