c/c++成长之路之面向对象 二 （构造函数与析构函数）

类的构造函数

类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。（方便给属性初始化赋值）

构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。构造函数可用于为某些成员变量设置初始值。

构造函数分为 有参构造，无参构造，拷贝构造。

无参构造

顾名思义，无参构造就是没有参数的构造函数，一般无参构造我们不实现时，编译器会自动实现一个空无参构造函数。若果我们定义了无参构造/有参构造/拷贝构造 编译器将不会自动生成无参构造

class box{
	public :		//公有属性 
		int l;  //长 
		int w;	//宽 
		int h;	//高 
	int get();	//定义体积计算方法 



	private:       //私有成员      外部对象不可访问操作，子类可以继承私有成员，但不可见，不能操作 
		
		
	protected:		//被保护成员 	外部对象不可访问操作，子类可访问操作 
						
	public:
		box(){
			cout<<"进入构造函数"<<endl; 		//构造函数 
		} ;
	
};

当创建一个对象时，构造函数会自动被调用。

无参构造创建对象时一定不要带括号，否则编译器会认为这是个函数声明

有参构造 

class box{
	public :		//公有属性 
		int l;  //长 
		int w;	//宽 
		int h;	//高 
	int get();	//定义体积计算方法 



	private:       //私有成员      外部对象不可访问操作，子类可以继承私有成员，但不可见，不能操作 
		
		
	protected:		//被保护成员 	外部对象不可访问操作，子类可访问操作 
						
	public:
		box(){
			cout<<"进入构造函数"<<endl; 		//构造函数 
		} ;
		box(int a){
			cout<<"进入有参构造"<<endl; 
		} 
		
	
};

有参构造的三宗写法

    box BOX(10);       
	box BOX=box(10);   //显式
	box BOX=10;        //隐式

拷贝构造

若我们不实现拷贝构造，编译器会自动生成一个拷贝构造，进行简单的拷贝赋值操作，若我们自己实现，编译器将不会自动生成 。另外对与拷贝构造的参数，

const不必多说，保护变量值不被修改，但要记住引用&一定不要少，如果不写，在传参时会进行赋值操作，内部会先执行  box p=BOX，这是声明对象的隐式写法，相当于box p(BOX),而box p(BOX)又会把BOX传给另外一个p会进入无线循环中，当然不写我们的编译器是会报错的。

class box{
	public :		//公有属性 
		int l;  //长 
		int w;	//宽 
		int h;	//高 
	int get();	//定义体积计算方法 



	private:       //私有成员      外部对象不可访问操作，子类可以继承私有成员，但不可见，不能操作 
		
		
	protected:		//被保护成员 	外部对象不可访问操作，子类可访问操作 
						
	public:
		box(){
			cout<<"进入构造函数"<<endl; 		//构造函数 
		} ;
		box(int a){
			cout<<"进入有参构造"<<endl; 
		} 
		box(const box &p)
		{
			cout<<"进入拷贝构造"<<endl; 
		}
	
};

补充，构造函数赋值方法

有参构造赋值

class box{
	public :		//公有属性 
		int l;  //长 
		int w;	//宽 
		int h;	//高 
	int get();	//定义体积计算方法 



	private:       //私有成员      外部对象不可访问操作，子类可以继承私有成员，但不可见，不能操作 
		
		
	protected:		//被保护成员 	外部对象不可访问操作，子类可访问操作 
						
	public:
	//	box():l(10),w(10),h(10){
		//	cout<<"进入构造函数"<<endl; 		//构造函数 
	//	} ;
	box(int a ,int b ,int c):l(a),w(b),h(c){
		cout<<"进入构造函数"<<endl;
	}
		box(int a){
			cout<<"进入有参构造"<<endl; 
		} 
		box(const box &p)
		{
			cout<<"进入拷贝构造"<<endl; 
		}
	
};
int box::get(){
	return l*w*h;
}


int main(void)
{
	box BOX(10,10,10);    //声明对象 
//	box BOX=box(10);
	box BOX1(BOX);
	cout<<BOX.get()<<endl;

}

无参构造赋值

#include <iostream>
using namespace std;

class box{
	public :		//公有属性 
		int l;  //长 
		int w;	//宽 
		int h;	//高 
	int get();	//定义体积计算方法 



	private:       //私有成员      外部对象不可访问操作，子类可以继承私有成员，但不可见，不能操作 
		
		
	protected:		//被保护成员 	外部对象不可访问操作，子类可访问操作 
						
	public:
		box():l(10),w(10),h(10){
			cout<<"进入构造函数"<<endl; 		//构造函数 
		} ;
//	box(int a ,int b ,int c):l(a),w(b),h(c){
//		cout<<"进入有参构造函数"<<endl;
//	}
		box(int a){
			cout<<"进入有参构造"<<endl; 
		} 
		box(const box &p)
		{
			cout<<"进入拷贝构造"<<endl; 
		}
	
};
int box::get(){
	return l*w*h;
}


int main(void)
{
	box BOX;    //声明对象 
//	box BOX=box(10);
	box BOX1(BOX);
	cout<<BOX.get()<<endl;

}

类的析构函数

类的析构函数是类的一种特殊的成员函数，它会在每次删除所创建的对象时执行。

析构函数的名称与类的名称是完全相同的，只是在前面加了个波浪号（~）作为前缀，它不会返回任何值，也不能带有任何参数。析构函数有助于在跳出程序（比如关闭文件、释放内存等）前释放资源。

#include <iostream>
using namespace std;

class box{
	public :		//公有属性 
		int l;  //长 
		int w;	//宽 
		int h;	//高 
	int get();	//定义体积计算方法 



	private:       //私有成员      外部对象不可访问操作，子类可以继承私有成员，但不可见，不能操作 
		
		
	protected:		//被保护成员 	外部对象不可访问操作，子类可访问操作 
						
	public:
		box():l(10),w(10),h(10){
			cout<<"进入构造函数"<<endl; 		//构造函数 
		} ;
//	box(int a ,int b ,int c):l(a),w(b),h(c){
//		cout<<"进入有参构造函数"<<endl;
//	}
		box(int a){
			cout<<"进入有参构造"<<endl; 
		} 
		box(const box &p)
		{
			cout<<"进入拷贝构造"<<endl; 
		}
	~box()
	{
		cout<<"进入析构"<<endl; 
	}
};
int box::get(){
	return l*w*h;
}
void test()
{
	box BOX;
}

int main(void)
{
test();

}

不难发现当test函数结束后，释放内存，这时自动进入析构，一般我们在堆上申请空间，释放的时候需要在析构里操作

析构函数用户不定义编译器也会自动生成