C++中产生临时对象的情况及其解决方案

更新时间：2024年05月28日 10:01:18 作者：weixin_44902783

这篇文章主要介绍了C++中产生临时对象的情况及其解决方案,以值传递的方式给函数传参,类型转换以及函数需要返回对象时,并给对应给出了详细的解决方案,通过图文结合的方式讲解的非常详细,需要的朋友可以参考下

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;
	}
 
	~TempObj()
	{
		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 << "<<<Leave 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++14、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;
	return tmp;
}
 
int main()
{
	TempObj m1 = GetObject();
	std::cout << "<<<Leave GetObject..." << std::endl;
	m1.Print("Variable  m1:");
 
	return 0;
}

运行结果：

在上述代码追踪构造函数和拷贝构造函数的调用，以及构造所发生的地址，以及提供一个打印函数，来打印某一个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++产生临时对象的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:

C++中virtual继承的深入理解
本篇文章是对C++中的virtual继承进行了详细的分析介绍，需要的朋友参考下
2013-05-05
用C实现PHP扩展 Fetch_Url 类数据抓取的方法
该扩展是基于libcurl基础实现的网页数据抓取
2013-04-04
用C语言获取文件的大小示例分享
在linux下获取一个指定文件大小（字节为单位）的代码。查了一下发现是使用系统调用stat来实现，那么如何使用C语言或C++语言来写一个通用的函数来获取指定文件大小的函数呢？
2014-08-08
C++语言基础命名空间
一个中大型软件往往由多名程序员共同开发，会使用大量的变量和函数，当有两个人都同时定义了一个名字相同的全局变量或函数的时候，若是把他们的代码整合在一块编译，此时编译器就会提示变量或函数重复定义，C++为了解决这个问题，便引用了命名空间(namespace)的概念
2020-01-01
C++设计模式之享元模式
这篇文章主要介绍了C++设计模式之享元模式,本文讲解了什么是享元模式、享元模式代码实例、享元模式的优点等内容,需要的朋友可以参考下
2014-10-10
C语言实现简单万年历
这篇文章主要为大家详细介绍了C语言实现简单万年历，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2020-02-02
C++实现LeetCode(158.用Read4来读取N个字符之二 - 多次调用)
这篇文章主要介绍了C++实现LeetCode(158.用Read4来读取N个字符之二 - 多次调用),本篇文章通过简要的案例,讲解了该项技术的了解与使用,以下就是详细内容,需要的朋友可以参考下
2021-07-07
基于C语言实现学生选课系统
这篇文章主要为大家详细介绍了基于C语言实现学生选课系统，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2019-02-02
C++ 算法精讲之贪心算法
贪心算法（又称贪婪算法）是指，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，他所做出的仅是在某种意义上的局部最优解
2022-03-03
深入解析C++中的std::thread的使用
这篇文章主要介绍了C++中的std::thread的使用,在C++11新标准中，可以简单通过使用thread库，来管理多线程，本文通过实例代码给大家详细讲解，需要的朋友可以参考下
2023-04-04