构造函数详解

类的6个默认成员函数

如果一个类中什么成员都没有，简称为空类。
空类中并不是什么都没有，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数

默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数(没写编译器就会默认生成,有点像缺省参数,不传值就自动帮你传默认的缺省值)

默认成员函数分为一下6种

构造函数:完成初始化
析构函数:完成清理(类似数据结构实现的Destroy函数)
拷贝构造函数:使同类对象初始化创建对象
赋值重载函数:把一个对象赋值给另一个对象
取地址重函数:对普通对象和const对象取地址

构造函数

概念

对于Date类，可以通过 Init 公有方法给对象设置日期，但如果每次创建对象时都调用该方法设置
信息，会有点麻烦，那能否在对象创建时，就将信息设置进去呢？

构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，以保证
每个数据成员都有 一个合适的初始值，并且在对象整个生命周期内只调用一次。

特性

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任
务并不是开空间创建对象，而是初始化对象(特别注意构造函数不是开空间)

构造函数语法

无参初始化

class Date
{
public:
	Date()
	{
		_year = 1;
		_month = 2;
		_day = 3;
	}
	void Print()
	{
		cout << _year << "/" << _month << "/"<<_day << endl;
	}

private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	d1.Print();
}

上面类中的函数Date函数名与类名Date相同,并且没有返回值(函数名之前没有int等返回类型)

类中的函数可以构成函数重载,即函数名相同,但是传入的参数类型不同…

class Date
{
public:
	Date()
	{
		_year = 1;
		_month = 2;
		_day = 3;
	}
	void Print()
	{
		cout << _year << "/" << _month << "/"<<_day << endl;
	}
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	d1.Print();
	Date d2(2024, 5, 7);
	d2.Print();
}

有人会注意到Date d1不像Date d2那样有括号,那可不可以在Date d1中加入括号变成Date d1()表示无参呢?

其实是不行的,原因是Date d1()会和函数声明区分不开,因为函数声明可能会是无参的函数比如Date func(),Date func()的功能可能就只是打印一句话,所以不需要传参

而Date d2(2024, 5, 7)不会报错的原因是因为对于需要传参的函数声明时是需要写出函数类型的,比如Date func(int…)

C++规定对象实例化的时候必须要调用默认构造函数

当我们屏蔽掉Date的时候就会报错

有参初始化

class Date
{
public:
	void Print()
	{
		cout << _year << "/" << _month << "/"<<_day << endl;
	}
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d2(2024, 5, 7);
	d2.Print();
}

由于默认构造函数比较特殊,所以写法和之前学习的类中的函数有些不同,比如就不能像下面这样去写

class Date
{
public:

	void Print()
	{
		cout << _year << "/" << _month << "/"<<_day << endl;
	}
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d2;
	d2.Date(2024,5, 7);
	d2.Print();
}

这个代码的意思是因为类名为Date,所以创建一个对象d2,因为类中有一个函数为Date,所以想去调用d2中的函数Date,但是最后的结果就会出错

构造函数是可以支持缺省参数的

class Date
{
public:
	/*Date()
	{
		_year = 1;
		_month = 2;
		_day = 3;
	}*/
	void Print()
	{
		cout << _year << "/" << _month << "/"<<_day << endl;
	}
	Date(int year=2024, int month=5, int day=7)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	d1.Print();
	Date d2(1);
	d2.Print();
}

但当把d2括号中传入的参数去掉后,就报错了

class Date
{
public:
	Date()
	{
		_year = 1;
		_month = 2;
		_day = 3;
	}
	void Print()
	{
		cout << _year << "/" << _month << "/"<<_day << endl;
	}
	Date(int year=2024, int month=5, int day=7)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	d1.Print();
	Date d2(1);
	d2.Print();
}

此外当取消屏蔽Date()时,有人可能会觉得Date()会和Date(int year=2024, int month=5, int day=7)构成函数重载,实际上也是可以的
但是因为Date(int year=2024, int month=5, int day=7)是缺省参数,会在使用的时候和Date()产生歧义,所以一般情况下都不会把这两个函数都同时写出来

构造函数特征总结

1. 函数名与类名相同。
2. 无返回值(不是像void,是根本不需要写返回类型)
3. 对象实例化时编译器自动调用对应的构造函数。
4. 构造函数可以重载。
5. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦
   用户显式定义编译器将不再生成
   编译器生产的默认构造函数有时并没有初始化
   这是因为C++将数据类型分为内置类型和自定义类型
   内置类型的含义就是语言自身定义的类型,比如int/char/double/指针…
   自定义类型就是自己定义的一些类型,比如struct/class
   C++规定默认生产的构造函数对于内置类型不做处理,而自定义类型会处理(有些编译器可能也会对内置类型进行处理,但是并不是C++规定的)

但是事实上自定义类型到最后都是内置类型具体如下,因为自定义类型内部一定是由内置类型去构成的,比如下面的代码,找到最后的class B,里面只有一个内置类型 int c,而这个内置类型int c最终还是需要我们去初始化

class B
{
	int c;
};
class A
{
public:

	B _b;
private:
	int a;
	int b;
};

class A
{
public:
	A()
	{
		cout << "A()" << endl;
		_a = 0;
	}
private :
	int _a;
};

class Date
{
public:
	void Print()
	{
		cout << _year << "/" << _month << "/"<<_day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
	A _aa;
};
int main()
{
	Date d2;
	d2.Print();
}

这个代码中Date对于自定义类型A会去调用他的默认构造函数,所以最后打印出A(),而内置类型没有调用,所以出现的是随机值

通过调试也可以看出,_aa的值是完成了初始化的

而在C++11后,这个语法可以支持在声明的位置给缺省值,但是要注意这不是定义,只是给了缺省值,有了缺省值,就会用给的缺省值去初始化

6. 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。
   注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为
   是默认构造函数(或者说是可以不需要传参就能调用构造函数的就是默认构造函数)
   无参构造函数、全缺省构造函数以及编译器默认生成的构造函数只能有一个存在(无参构造和全缺省构造同时存在会有歧义)

class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "/" << _month << "/"<<_day << endl;
		
	}
private:
	int _year=1;
	int _month=1;
	int _day=1;
};
int main()
{
	Date d2;
	d2.Print();
}

这段代码的报错为不存在默认构造函数或,没有合适的默认构造函数可用

这是因为当我们没有自己写默认构造函数的时候,编译器回去自己创造一个默认构造函数,而当我们写了默认构造函数的时候,编译器就会去调用我们写的默认构造函数,代码中我们写了一个带参的默认构造,所以编译器不会去自己创造一个默认构造函数,