C++中的构造函数小结

对象的初始化

对象时类的实例，类是不占用空间的，对象是占用空间的。

因为类是抽象的，不占用空间的，所以我们不能再定义类的时候对对象进行初始化操作的。

但是，我们可以定义一个函数，在类实例化一个对象的时候，对对象赋初值，这个函数就叫做构造函数。

构造函数是类在定义对象的时候，自动执行的对对象中的数据进行初始化操作的函数。

构造函数的作用

构造函数不同于其他的函数，不需要用户调用它（用户也不可以调用这个函数），而是在建立对象时自动执行的。构造函数的名字必须与类名相同，以便编译系统能识别它并把它作为构造函数处理。

它不具有任何类型，不返回任何值。构造函数的功能是由用户定义的，用户根据初始化的要求设计函数体和函数参数。

===================例子1===================================

#include<iostream>
using namespace std;
class Time{
	public:
		Time(){//定义构造函数，注意函数名必须与类名相同
			hour=10;
			minute=10;
			sec=10;
		}
		void set_time();
		void show_time();
	private:
		int hour;
		int minute;
		int sec;
};
void Time::set_time(){
	cout<<"hour :";
	cin>>hour;
	cout<<"minute :";
	cin>>minute;
	cout<<"sec :";
	cin>>sec;
}
void Time::show_time(){
	cout<<"Time : "<<hour<<":"<<minute<<":"<<sec<<endl;
}
int main(){
	Time t1;
	t1.show_time();
	cout<<"======================="<<endl;
	Time t2;
	t2.set_time();
	t2.show_time();
}

当然，构造函数也可以在类外定义：

#include<iostream>
using namespace std;
class Time{
	public:
		Time();
		void set_time();
		void show_time();
	private:
		int hour;
		int minute;
		int sec;
};
Time::Time(){//注意构造函数是没有返回值的
			hour=10;
			minute=10;
			sec=10;
 }
void Time::set_time(){
	cout<<"hour :";
	cin>>hour;
	cout<<"minute :";
	cin>>minute;
	cout<<"sec :";
	cin>>sec;
}
void Time::show_time(){
	cout<<"Time : "<<hour<<":"<<minute<<":"<<sec<<endl;
}
int main(){
	Time t1;
	t1.show_time();
	cout<<"======================="<<endl;
	Time t2;
	t2.set_time();
	t2.show_time();
}

构造函数的声明和定义与其他的函数是有区别的，它没有返回值。

构造函数的3个特点：

1.函数的调用是在类对象进入其作用域时自动调用的。

2.构造函数没有返回值，因此也不需要在定义构造函数时声明类型，这是它和一般函数的一个重要的不同之处。

不能写成：

否则会报错

3.构造函数不需要用户调用，也不能被用户调用。

这样写是错误的：

否则会报错

构造函数是在建立对象时由系统自动执行的，而且只能执行一次。

构造函数一般声明为public,若声明成private就会报错。

带参数的构造函数

上面介绍的构造函数虽然可以初始化对象，但是用来初始化的值都是一样的，这显然不符合实际情况。

带参数的构造函数就是用来解决这个问题的，它可以实现在调用不同对象的时候，用不同的值进行初始化。

一般格式是：

构造函数名（类型1 形参1,类型2 形参2,……）

构造函数的第三个特点是它不能采用常规的调用函数的方法给出实参（如，fun(a,b)），

实参是在定义对象时给出的，定义对象的一般格式是：

类名 对象名（实参1,实参2,……）

也就是说，它是在定义对象的时候进行传值的。

=========================例子2==============================

有两个长方体，其长宽高分别是：（1）12,20,25（2）10,14,20。分别求它们的体积

#include<iostream>
using namespace std;
class Box{
	public:
		Box(int,int,int);//声明带参数的构造函数
		int volume();//声明求体积的函数
       private:
		int height;
		int width;
		int length;
};
Box::Box(int h,int w,int l){//定义带参数的构造函数
	height=h;
	width=w;
	length=l;
}
int Box::volume(){//定义求体积的函数
	int z;
	z=height*width*length;
	return z;
}
int main(){
	Box b1(10,10,10);
	cout<<"Volume of b1 : "<<b1.volume()<<endl;
	Box b2(10,20,30);
	cout<<"Volume of b2 : "<<b2.volume()<<endl;
	return 0;
}

可以知道：

（1）带参数的构造函数中的形参，其对应的实参在定义对象时给定。

（2）用这种方法可以方便地实现对不同的对象进行不同的初始化。

用参数初始化表对数据成员初始化

这种烦好伐不在函数体内对数据成员初始化，而是在函数首部实现。

Box::Box(int h,int w,int l):height(h),width(w),length(l){}

即，在原来函数首部的末尾加一个冒号，然后列出参数的初始化表。

上面的初始化表表示：用形参h的值初始化数据成员height;用形参w的值初始化数据成员width;用形参l的值初始化数据成员。

这种写法更加方便，简单，尤其当需要初始化的数据成员较多的时候，更显其优越性~

然而，很多时候，我们不仅需要不同的对象的初始化值不同，有些时候我们还想要使用默认的一些初始化值。

有两种方法可以实现：

构造函数的重载

在一个类中定义多个构造函数，以便对类对象提供不同的初始化方法，供用户选用。这些构造函数具有相同的名字，而参数的个数或参数的类型不同。

#include<iostream>
using namespace std;
class Box{
	public:
		Box(int,int,int);//含参数的构造函数
		Box();//不含参数的构造函数
		int volume();
	private:
		int height;
		int width;
		int length;
};
Box::Box(){
	height=0;
	width=0;
	length=0;
}
Box::Box(int h,int w,int l):height(h),width(w),length(l){}
int Box::volume(){
	int z;
	z=height*width*length;
	return z;
}
int main(){
	Box b1;//实例化对象的时候没有进行传值
	cout<<"Volume of b1 : "<<b1.volume()<<endl;
	Box b2(10,20,30);//实例化对象的时候进行传值
	cout<<"Volume of b2 : "<<b2.volume()<<endl;
	return 0;
}

编译系统是根据函数调用（在类实例化对象的时候自动进行）的时候，是否传值，以及传值的个数和类型进行判断的。

（1)调用构造函数的时候，不必给出实参的构造函数，成为默认构造函数（或称为缺省构造函数）。

显然，无参构造函数属于默认构造函数，而且一个类只能定义一个默认构造函数。

（2）尽管在一个类中可以包含多个构造函数，但是对于每一个对象来说，建立对象时只执行其中一个构造函数，并非每个构造函数都被执行。

使用默认参数的构造函数

#include<iostream>
using namespace std;
class Box{
	public:
		Box(int h=1,int w=1,int l=1);//含默认参数的构造函数
		int volume();
	private:
		int height;
		int width;
		int length;
};
Box::Box(int h,int w,int l):height(h),width(w),length(l){}
int Box::volume(){
	int z;
	z=height*width*length;
	return z;
}
int main(){
	Box b1;
	cout<<"Volume of b1 : "<<b1.volume()<<endl;
	Box b2(10,20,30);
 	cout<<"Volume of b2 : "<<b2.volume()<<endl;
	return 0;
}

（1）默认参数可以在声明构造函数的时候指定，也可以在定义构造函数的时候指定

Box::Box(int h=1,int w=1,int l=1):height(h),width(w),length(l){}

（2）在声明构造函数的时候，形参名可以省略，即简写成：

Box(int =1,int =1,int =1);//含参数的构造函数

（3）如果构造函数的全部参数都指定了默认值，则在定义对象时可以给定一个或者几个实参，也可以不给出实参。

Box b2(10,20);

对应的结果是200

前面说了，不需要实参也可以调用的构造函数成为缺省构造函数，并且，一个类只能有一个缺省构造函数，也就是说可以不使用参数而调用的构造函数，一个类只能有一个。

其道理是显然的，因为缺省构造函数不唯一的话，编译系统就不知道在实例化对象的时候，没有传递实参的情况下，应该调用哪一个函数了。

转载于:https://www.cnblogs.com/zhezh/p/3773525.html