C++_引用与析构，通过引用减少临时变量

最新推荐文章于 2022-07-31 21:41:36 发布
最新推荐文章于 2022-07-31 21:41:36 发布
阅读量2.5k 收藏 4
点赞数 2
分类专栏： C++ 文章标签： C++ 复制构造函数 参数 临时变量 生命周期
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010003835/article/details/47166449
版权

通过引用可以大大减少创建临时变量的次数，从而提高程序运行的效率。

本文探讨创建通过引用减少创建临时变量的次数，与临时变量的生命周期。


测试一：不使用引用并且返回的临时变量不用引用保存。


#include <cstdio>
#include <iostream>

using namespace std;


class Point{
private:
	static int count;
	int x;

public:
	Point() {
		printf("constructor called\n");
		x = ++Point::count;
	}

	Point(const Point &B){
		printf("copy constructor called\n");
		x  = ++Point::count;
	}


	~Point(){
		printf("xx %d\n",x);
	}

	Point XX(Point x)
	{
		//this->x = 0;

		return x;
	}

	void print()const{
		printf("%d\n", x);
	}


};

int Point::count = 0;

int main(){
	Point pt;
	Point pk;
	//Point &pz = 
	pt.XX(pk);
	//pz.print();
	pt.print();

	return 0;
}


运行截图


通过以上输出，可以看出发生了4次析构，说明产生了两个临时变量。

3,4为临时变量。

第一个临时变量为3, 3为传递进来的参数调用了复制构造函数,

生命周期：在函数执行完成后即进行析构。

第二个临时变量为4, 4为返回的参数, 其调用了复制构造函数

生命周期：在完成对原有变量赋值（隐含复制操作）即进行析构。




测试二：不使用引用并且返回的临时变量并使用引用保存。

#include <cstdio>
#include <iostream>

using namespace std;


class Point{
private:
	static int count;
	int x;

public:
	Point() {
		printf("constructor called\n");
		x = ++Point::count;
	}

	Point(const Point &B){
		printf("copy constructor called\n");
		x = ++Point::count;
	}


	~Point(){
		printf("xx %d\n", x);
	}

	Point XX(Point x)
	{
		//this->x = 0;

		return x;
	}

	void print()const{
		printf("%d\n", x);
	}


};

int Point::count = 0;

int main(){
	Point pt;
	Point pk;
	Point &pz = pt.XX(pk);
	//pz.print();
	pt.print();

	printf("haha\n");

	return 0;
}



运行截 图


通过以上输出，可以看出发生了4次析构，说明产生了两个临时变量。

3,4为临时变量。

第一个临时变量为3, 3为传递进来的参数调用了复制构造函数,

生命周期：在函数执行完成后即进行析构。

第二个临时变量为4, 4为返回的参数, 其调用了复制构造函数

生命周期：在完成对原有变量赋值（隐含复制操作）由于又使用了引用对其（临时变量）保存，故该临时变量生存周期同引用生存周期。

在函数最后进行析构，但由于声明变量的顺序与析构顺序相反，析构序号为4,2,1



测试三：对传进来的参数使用引用，返回值不使用引用，返回的临时变量（引用）使用引用保存。

#include <cstdio>
#include <iostream>

using namespace std;


class Point{
private:
	static int count;
	int x;

public:
	Point() {
		printf("constructor called\n");
		x = ++Point::count;
	}

	Point(const Point &B){
		printf("copy constructor called\n");
		x = ++Point::count;
	}


	~Point(){
		printf("xx %d\n", x);
	}

	Point XX(Point &x)
	{
		//this->x = 0;

		return x;
	}

	void print()const{
		printf("%d\n", x);
	}


};

int Point::count = 0;

int main(){
	Point pt;
	Point pk;
	Point &pz = pt.XX(pk);
	//pz.print();
	pt.print();

	printf("haha\n");

	return 0;
}



通过以上输出，可以看出发生了3次析构，说明产生了一个临时变量。

3为临时变量。

第一个临时变量3, 3为返回的参数, 其调用了复制构造函数

生命周期：在完成对原有变量赋值（隐含复制操作）由于又使用了引用对其（临时变量）保存，故该临时变量生存周期同引用生存周期。

在函数最后进行析构，但由于声明变量的顺序与析构顺序相反，析构序号为3,2,1



测试四：对传进来的参数不使用引用，返回值使用引用，返回的临时变量（引用）使用引用保存。

#include <cstdio>
#include <iostream>

using namespace std;


class Point{
private:
	static int count;
	int x;

public:
	Point() {
		printf("constructor called\n");
		x = ++Point::count;
	}

	Point(const Point &B){
		printf("copy constructor called\n");
		x = ++Point::count;
	}


	~Point(){
		printf("xx %d\n", x);
	}

	Point& XX(Point x)
	{
		//this->x = 0;

		return x;
	}

	void print()const{
		printf("%d\n", x);
	}


};

int Point::count = 0;

int main(){
	Point pt;
	Point pk;
	Point &pz = pt.XX(pk);
	//pz.print();
	pt.print();

	printf("haha\n");

	return 0;
}


通过以上输出，可以看出发生了3次析构，说明产生了一个临时变量。

3为临时变量。

第一个临时变量3, 3为传递进去的对象, 其调用了复制构造函数

生命周期：在函数调用的时候使用了复制构造函数，函数执行完成后立即进行析构。




测试五：对传进来的参数使用引用，返回值使用引用， 返回的临时变量（引用）使用引用保存。 

#include <cstdio>
#include <iostream>

using namespace std;


class Point{
private:
	static int count;
	int x;

public:
	Point() {
		printf("constructor called\n");
		x = ++Point::count;
	}

	Point(const Point &B){
		printf("copy constructor called\n");
		x = ++Point::count;
	}


	~Point(){
		printf("xx %d\n", x);
	}

	Point& XX(Point &x)
	{
		//this->x = 0;

		return x;
	}

	void print()const{
		printf("%d\n", x);
	}


};

int Point::count = 0;

int main(){
	Point pt;
	Point pk;
	Point &pz = pt.XX(pk);
	//pz.print();
	pt.print();

	printf("haha\n");

	return 0;
}


通过以上输出，可以看出发生了2次析构，说明没产生临时变量。



测试六：对传进来的参数不使用引用，返回值使用引用，返回的临时变量（引用）使用引用保存。

#include <cstdio>
#include <iostream>

using namespace std;


class Point{
private:
	static int count;
	int x;

public:
	Point() {
		printf("constructor called\n");
		x = ++Point::count;
	}

	Point(const Point &B){
		printf("copy constructor called\n");
		x = ++Point::count;
	}


	~Point(){
		printf("xx %d\n", x);
	}

	Point& XX(Point x)
	{
		//this->x = 0;

		return x;
	}

	void print()const{
		printf("%d\n", x);
	}


};

int Point::count = 0;

int main(){
	Point pt;
	Point pk;
	Point &pz = pt.XX(pk);
	pz.print();
	pt.print();

	printf("haha\n");

	return 0;
}


通过以上输出，可以看出发生了3次析构，说明产生了一个临时变量。

3为临时变量。

第一个临时变量3, 3为传递进去的对象, 其调用了复制构造函数

生命周期：在函数调用的时候使用了复制构造函数，函数执行完成后立即进行析构。而我使用一个引用对返回的临时变量进行了保存，但在完成

赋值之后

Point &pz = pt.XX(pk);

即这条语句之后，该临时变量进行了析构，之后调用的print 函数打出了被释放后的内存区域，需要十分注意



测试七：对传进来的参数使用引用，返回值不使用引用，返回的临时变量（引用）使用引用保存。

#include <cstdio>
#include <iostream>

using namespace std;


class Point{
private:
	static int count;
	int x;

public:
	Point() {
		printf("constructor called\n");
		x = ++Point::count;
	}

	Point(const Point &B){
		printf("copy constructor called\n");
		x = ++Point::count;
	}


	~Point(){
		printf("xx %d\n", x);
	}

	Point XX(Point &x)
	{
		//this->x = 0;

		return x;
	}

	void print()const{
		printf("%d\n", x);
	}


};

int Point::count = 0;

int main(){
	Point pt;
	Point pk;
	Point &pz = pt.XX(pk);
	pz.print();
	pt.print();

	printf("haha\n");

	return 0;
}


通过测试1-6，我们不难发现由于返回的对象为赋值的对象，该临时对象的生命周期为引用的生命周期，所以在pritnf("haha\n");

后进行释放，即main结束时进行释放。




通过以上测试，可以看出

1.若函数传递的参数为对象，且需要返回该对象。

应该在函数传递参数以及函数返回时都使用引用，这样会减少两次临时变量的产生。（测试一~测试五）


2.若对参数调用复制构造函数,返回使用引用，在赋值完成之后，该复制构造函数产生的临时变量的内存空间就被回收（见测试六）

高达一号
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
C++中部分知识点，引用、this指针、构造函数和析构函数、函数重载
zlb1051的博客
04-11 312
1.引用类型引用类型是C++新增（相对C语言）的一种类型，引用是已定义的变量（对象）的别名。引用的定义方法为类型名 &amp; 引用变量名 = 被引用变量名；int i = 0; int b = 5; int &amp;ri = i; ri = b; //这实际上将i和ri的值改为了5，而不是使ri引用b 引用的本质实际上是一个常量指针，int * const rp = &amp;i; ...
C++变量的引用 | 使用变量的引用
weixin_48669767的博客
12-24 2841
C++变量的引用 C++可以对一个数据可以使用引用，引用是C++对C语言的一个重要扩充，引用是一种新的变量类型， 它的作用是为一个变量起一个别名。 比如要给变量temp起个别名change： int temp;//定义整型变量temp int &change=temp;//声明change是temp的引用 上述代码声明了change是temp的引用，即change是temp的别名，经过上述声明后，change和temp的作用相同，都表示同一变量，&是引用声明符，并不代表地址，读者不要理解为
C++ const引用、临时变量 引用参数详解
01-01
C++引用—临时变量、引用参数和const引用 如果实参与引用参数不匹配，C++将生成临时变量。如果引用参数是const,则编译器在下面两种情况下生成临时变量： 实参类型是正确的，但不是左值 实参类型不正确，但可以转换为正确的类型 左值参数是可被引用的数据对象，例如，变量、数组元素、结构成员、引用和被解除引用的指针都是左值，非左值包括字面常量和包含多项式的表达式。定义一个函数 Double refcube(const double& ra) { Returnra*ra*ra; } double side = 3.0; double* pd = &side; double& rd
C++：构造、析构、引用与拷贝构造
WangGarrison的博客
10-27 897
构造函数 类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。 类的数据成员多为私有的，要对它们进初始化，必须用一个公有函数来进行。同时这个函数应该在且仅在定义对象时自动执行一次。这个函数就是构造函数。它由系统自动调动，用户不可以调动。 构造函数是类的特殊的公有成员函数，有如下特征： 函数名与类名相同，如：CGoods(); 无函数返回类型说明（注意：是没有而不是void，即什么也不写，不可写void。实际上构造函数有返回值，返回的是构造函数所创建的对象） 系统自动调用。在程
引用类的析构函数和终结器
xumuge的专栏
03-09 942
摘要：《Visual C++ 2008入门经典》第9章类继承和虚函数，本章我们将研究面向对象编程的核心主题-- 类继承。本小节为大家介绍引用类的析构函数和终结器。      我们可以用为本地C++类定义析构函数时所用的相同方式，为引用类定义析构函数。当某个引用类的句柄离开其作用域时，或者当该类的对象是另一个正在被销毁的对象的组成部分时，类的析构函数将被调用。我们也可以对引用类的句柄应用delete运算符，这样也会调用析构函数。为本地C++类实现析构函数的首要原因是要处理在堆上分配的数据成员，但该理由显然不适
C++线程中对象作为参数，析构问题
百冰千岚的博客
07-01 367
C++线程中，C++对象作为参数时，可能会出现对象析构 解决办法，用std::ref，boost::ref，或者使用指针。 现象如下： class testA { public: testA() :a(100) { qDebug() << "testA()!"; } ~testA() { std::cout << "--- ~~~testA()--析构--!\n"; } testA(const testA& t) :a(t.a) { std::cout
【C++】C++11新特性
lsz20000813的博客
04-26 890
委托构造函数 C++11 标准提出了委派构造函数新特性。利用这个特性，程序员可以将公有的类成员构造代码集中在某一个构造函数里，这个函数被称为目标构造函数。其他构造函数通过调用目标构造函数来实现类成员构造，这些构造函数被称为委派构造函数。在该新特性提出之前，构造函数是不能显式被调用的，委派构造函数打破了这一限制 class CGoods { public: CGoods():CGoods("\0", 0, 0, 0) //： CGoods("\0", 0) {} { } CGoods(string
c++临时对象以及引用的一些知识
admin的博客
12-23 2474
一：先来讲讲什么是临时对象。 临时对象（临时变量）：代码中看不见，隐藏在后台，因此我们无法在程序代码中看见临时对象。 临时对象的产生条件有两个： 1.为使函数调用成功而进行隐式类型转换时用到 2.函数返回值的时候用到 ...
C++非const的引用不能指向临时对象
Sunshine的专栏
10-23 2888
http://blog.csdn.net/jiafu1115/article/details/8865964
C++语言的对象——构造和析构
qq_45652092的博客
10-28 217
析构函数和构造函数概述L:
C++_的引用的析构，引用空间的释放
迎难而上
10-29 5387
今天遇到一个问题，C++中的引用变量，如果引用被析构，原数据是否会存在，例如 int a = 5; int& b = a;  delete &b; a是否能被访问到，博主写了个测试程序。 经测试，数据已经通过析构函数被释放不能，相当于数据空间已经被回收，望大家注意。 附上测试代码和测试的流程图： #include #include using namespace std; class
c++中临时变量不能作为非const的引用参数的方法
08-31
总结来说，C++中临时变量不能作为非const引用参数的原因在于： 1. 非const引用暗示了函数可能修改引用的对象，而临时对象的修改通常是无意义的，因为它们的生命周期短暂。 2. 编译器无法确保临时对象的修改能够影响...
C++11引用临时变量的解析
12-22
工作中遇到一个引用临时变量的问题，经过两天的学习，私以为：不仅弄明白了这个问题，还有些自己的独到见解。 　这里使用一个简单的例子来把自己的学习过程和理解献给大家，如果有什么问题请不吝指正。 　********...
fraction_C++_fraction_fraction变量_
10-01
定义一个分数类（Fraction） 实例变量：分子，分母 方法：初始化方法（2个参数），便利构造器，约分，打印，加，减，乘，除。
【C++ 析构函数】当指向一个对象的引用或指针离开作用域时，析构函数不会执行。
qq_44055933的博客
07-31 582
当指向一个对象的引用或指针离开作用域时，析构函数不会执行。
C++引用不能绑定到临时数据
luoganttcc的博客
11-05 1148
我们知道，指针就是数据或代码在内存中的地址，指针变量指向的就是内存中的数据或代码。这里有一个关键词需要强调，就是内存，指针只能指向内存，不能指向寄存器或者硬盘，因为寄存器和硬盘没法寻址。 其实 C++ 代码中的大部分内容都是放在内存中的，例如定义的变量、创建的对象、字符串常量、函数形参、函数体本身、new或malloc()分配的内存等，这些内容都可以用&来获取地址，进而用指针指向它们。除此之外，还有一些我们平时不太留意的临时数据，例如表达式的结果、函数的返回值等，它们可能会放在内存中，也可能会放在寄
引用成员不会被父类的析构销毁
sesiria的博客
04-03 1259
一，成员引用的方式。将某个成员申明为类的引用方式，（其实就是指针）发现类的析构函数并不会销毁引用成员。#include &lt;iostream&gt; class A { public: A() { std::cout &lt;&lt; "create A" &lt;&lt; std::endl; } A(const A&amp; a) ...
C/C++__如何创建一个空字符串数组
热门推荐
迎难而上
07-27 2万+
字符串数组在使用前应进行初始化操作。 下面介绍两种创建空字符串数组的方法 初始化方法1 char  szFileName[MAXN]  = {0}            /**其结果相当于memset(szFileName,0,sizoef(szFileName)); *即对字符串数组中的每个数据都初始化为(ASCII)0 即 "\0"  **/ 初始化方法2 c
c++返回临时变量的常量引用
最新发布
07-16
当你返回一个临时变量的常量引用时，确保返回的引用类型与临时变量类型一致，并将其声明为常量引用。这样可以确保返回值不会被修改，并且可以避免不必要的拷贝操作。 以下是一个示例代码片段，演示了如何返回一个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值