亲宝软件园·资讯

展开

C++类的构造与析构

是星星鸭 人气:0

一、类的构造函数

什么是构造函数

和类具有相同名称,并且没有返回值类型的函数,就是类的构造函数

概念模糊、直接举例:

#include <stdio.h>
#include <windows.h>
struct Test
{
    Test()        // 和类具有相同的名、并且没有返回值
    {
    }
};
int main()
{
    return 0;
}

构造函数的特点

直接先来说特点吧,然后论证:

1、构造函数在定义对象的时候被调用

2、构造函数可以进行函数重载,可以有很多个

3、创建对象时默认调用的是无参构造

证明1:

构造函数在定义对象的时候被调用;

论证如下:

#include <stdio.h>
struct Test
{
	Test()
	{
		printf("你调用了构造函数\n");		// 此处下断点、如果该函数被调用肯定会停下来。
	}
};
int main()
{
	Test te;
	printf("接力\n");
	return 0;
}

我们在Test()构造的输出语句上加断点、当程序调用Test的printf肯定会停下来,这个时候我们转到反汇编,单步步过、直到函数返回之后,就能知到刚刚是在哪里调用的构造函数了

vs2010:F7编译、F5调试、ALT+8反汇编:

F10一直运行到返回:

这里编译器做了优化,可以直接看出来是在Test定义对象的时候调用了构造。

证明2:

构造函数可以进行函数重载,可以有很多个;

论证如下:

#include <stdio.h>
#include <Windows.h>
struct Test
{
	Test()
	{
		printf("你调用了构造函数\n");		// 此处下断点、如果该函数被调用肯定会停下来。
	}
	Test(int a)
	{
		printf("重载%d\n",a);
	}
	Test(int a, int b)
	{
		printf("重载%d\n",a+b);
	}
};
int main()
{
	Test te;
	Test te1(1);
	Test te2(1,1);			// 注意、调用有参的构造函数时,需要传递参数
	system("pause");
	return 0;
}

重载了两个,注意:调用有参数的构造时,需要传递参数。

运行可以通过:

证明3:

创建对象时默认调用的是无参构造;

论证如下:

#include <stdio.h>
#include <Windows.h>
struct Test
{
	Test(int a)
	{
		printf("重载%d\n",a);
	}
	Test(int a, int b)
	{
		printf("重载%d\n",a+b);
	}
};
int main()
{
	Test te;            // 普通定义对象的方式、不带参数
	system("pause");
	return 0;
}

首先我们删除无参构造,看看能否编译通过:

不可以

然后删除有参构造:

#include <stdio.h>
#include <Windows.h>
struct Test
{
	Test()
	{
		printf("你调用了构造函数\n");		// 此处下断点、如果该函数被调用肯定会停下来。
	}
};
int main()
{
	Test te;
	system("pause");
	return 0;
}

可以

全部都加上:

#include <stdio.h>
#include <Windows.h>
struct Test
{
	Test()
	{
		printf("你调用了构造函数\n");		// 此处下断点、如果该函数被调用肯定会停下来。
	}
	Test(int a)
	{
		printf("重载%d\n",a);
	}
	Test(int a, int b)
	{
		printf("重载%d\n",a+b);
	}
};
int main()
{
	Test te;
	system("pause");
	return 0;
}

运行结果:

这已经证明了,Test te;平常这样定义对象的时候,调用的是无参构造。如果需要调用有参构造,必须传入参数;

这个特点很简单、有参函数肯定要传参嘛,所以定义对象的时候肯定要传入参数啊;

但是这里建议无论什么时候写类,最好还是写上无参构造,哪怕什么都不做也尽量写上,避免不必要的麻烦。

构造函数的作用

一般用于初始化类的成员

如下:

#include <stdio.h>
#include <Windows.h>
struct Test
{
	int x;
	int y;
	int z;
	Test()
	{
	}
	Test(int x,int y,int z)						// 构造函数初始化对象
	{
		this->x = x;
		this->y = y;
		this->z = z;	
	}
};
int main()
{
	Test te;
	Test te1(1,2,3);							// 定义对象并调用有参构造进行初始化
	printf("%d %d %d\n",te1.x,te1.y,te1.z);		// 输出看看是否初始化成功
	system("pause");
	return 0;
}

运行如下:

初始化成功。

二、类的析构函数

什么是析构函数

类的构造函数名前加上'~'这个符号,就是类的析构函数

概念模糊、代码如下:

#include <stdio.h>
#include <Windows.h>
struct Test
{
	Test()
	{
		printf("你调用了一次类的构造函数\n");
	}
	~Test()
	{
		printf("你调用了一次类的析构函数\n");
	}
};
int main()
{
	Test te;
	// system("pause");        // 这里就不要让程序停下来了,不然析构不了
	return 0;
}

~Test(){}就这个样子

析构函数的特点

依然直接先来说特点,然后论证:

1、析构函数不能重载、不能有参数

2、析构函数在变量声明周期结束时被调用

3、析构函数被调用分两种情况:堆栈中定义的对象、全局区中定义的对象

证明1:

析构函数不能重载、不能有参数;

编译不通过。

既然不能有参数,那重载更不可能了

证明成功。

证明2:

析构函数在变量声明周期结束时被调用;

局部变量的生命周期是在一个大括号内,即一个所处块结束。

所以:

#include <stdio.h>
#include <Windows.h>
struct Test
{
	Test()
	{
		printf("你调用了一次类的构造函数\n");
	}
	~Test()
	{
		printf("你调用了一次类的析构函数\n");
	}
};
int main()
{
	{
		Test te;
		printf("te生命周期即将结束。\n");
	}                                    // 析构应该在这里被调用
	printf("te生命周期结束。\n");
	system("pause");
	return 0;
}

运行结果如下:

断点

结果

证明成功。

证明3:

析构函数被调用分两种情况:堆栈中定义的对象、全局区中定义的对象;

已知堆栈中定义的对象(局部变量)在块语句结束之后就会被调用,那么带有return的main函数是在返回前调用析构,还是返回后呢?

代码如下:

#include <stdio.h>
#include <Windows.h>
struct Test
{
	Test()
	{
		printf("你调用了一次类的构造函数\n");
	}
	~Test()
	{
		printf("你调用了一次类的析构函数\n");			// 断点--汇编
	}
};
int main()
{
	Test te;
	// system("pause");					// 不要使用pause,不然无法返回
	return 0;
}

断点-调试-汇编:

可以看到是在函数返回前被调用的。

如果在全局区定义的对象呢?

这个问题很难说,像我一样定义两个断点就行了,如下:

#include <stdio.h>
#include <Windows.h>
struct Test
{
	Test()
	{
		printf("你调用了一次类的构造函数\n");
	}
	~Test()                                    // 断点
	{
		printf("你调用了一次类的析构函数\n");			
	}
};
Test te;
int main()
{
	// system("pause");					// 不要使用pause,不然无法返回
	return 0;                           // 断点
}

运行:

发现一运行就断在了return,当我们发F10继续运行的时候,并没有直接调用析构,而是到了括号那里:

继续F10:

通过翻译,可以得知这就是进程结束时的一些收尾工作。

继续F10:

现在大概可以总结了,类的对象定义为全局变量时,是在main函数结束之后进程退出之前,调用的析构函数。

小结

当类的对象定义为局部变量时(堆栈),定义这个对象的块作用域结束时就会调用该对象的析构函数,如果在main函数这个块作用域中定义的对象,那么就是在return之前调用析构。

当类的对象定义为全局变量时(全局区),会在main函数return函数返回之后和进程结束之前,调用该对象的析构函数。

析构函数的作用

我们知道了析构函数都是在类的对象生命周期结束时被调用,那么就代表下面不会再使用到这个对象;所以析构函数一般用于一些收尾的工作,以防忘记。

比如当你使用了该对象的成员申请了内存(malloc、new等)、或者open了一些文件,那么可以在析构函数中free delete 或者close。

例如:

#include <stdio.h>
#include <Windows.h>
struct Test
{
	int x;
	char* name;
	Test()
	{
		name = (char*)malloc(sizeof(char)*20);        // 构造时动态申请
	}
	~Test()
	{
		if(this->name!=0)                             // 析构时判断是个否为空,不为空释放
		{
			free(name);
			name = 0;
		}
	}
};
int main()
{
	Test te;
	return 0;
}

这里我就不运行了,大家可以自己测试下。

总结

构造函数

1、和类具有相同名称,并且没有返回值类型的函数,就是类的构造函数

2、构造函数在定义对象的时候被调用

3、构造函数可以进行函数重载,可以有很多个

4、创建对象时默认调用的是无参构造

析构函数

1、类的构造函数名前加上'~'这个符号,就是类的析构函数

2、析构函数不能重载、不能有参数

3、析构函数在变量声明周期结束时被调用

4、析构函数被调用分两种情况:堆栈中定义的对象、全局区中定义的对象

加载全部内容

相关教程
猜你喜欢
用户评论