C++奇迹之旅：构造函数

文章目录

• 📝类的6个默认成员函数
• [🌠 构造函数](#🌠 构造函数)
• • [🌉 概念](#🌉 概念)
  • 🌉特性
  • 🌉三种默认构造函数
• 🚩总结

---

📝类的6个默认成员函数

如果一个类中什么成员都没有，简称为空类 。

空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。

class Date {};

🌠 构造函数

🌉 概念

对于以下Date类：

class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	d1.Init(2006, 6, 27);
	d1.Print();

	Date d2;
	d2.Init(2022, 7, 6);
	d2.Print();
	return 0;
}

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

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

🌉特性

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

其特征如下：

1. 函数名 与类名相同。
2. 无返回值。
3. 对象实例化时编译器自动调用对应的构造函数。
4. 构造函数可以重载。
   构造函数可以重载，主要分为两类：

• 无参构造函数

class Date
{
public:
	//无参构造函数
	Date()
	{}

	void print()
	{
		cout << _year << _month << _day << endl;
	}

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1;//调用无参构造函数
	
	d1.print();
	return 0;
}

这样的无参构造，依然是初始化为随机数。

注意：如果无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明

• 带参构造函数

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;
	int _month;
	int _day;
};

int main()
{
	Date d2(2024, 4, 15);//调用带参构造函数
						//带参是要直接在后面加括号的
	d2.print();
	return 0;
}

调用带参构造函数，带参是要直接在后面加括号的 。

两者结合，构成重载关系：

5. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。

没有显示构造函数

代码可以通过编译，因为编译器生成了一个无参的默认构造函数,对象实例化，编译器调用自动调用默认构造函数，这多好啊，都不用自己实现，但是使用编译器实现的默认构造函数出来初始化的数据是随机值，不是0，这就有点麻烦了。

而如果我们显示实现呢？

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;
	int _month;
	int _day;
};

int main()
{
	Date d2(2024, 4, 15);//调用带参构造函数
						//带参是要直接在后面加括号的
	d2.print();
	return 0;
}

一旦自己显式定义任何构造函数，编译器将不再生成。

6. 关于编译器生成的默认成员函数，很多童鞋会有疑惑：不实现构造函数的情况下，编译器会生成默认的构造函数。但是看起来默认构造函数又没什么用？d对象调用了编译器生成的默认构造函数，但是d对象_year/_month/_day，依旧是随机值。也就说在这里编译器生成的默认构造函数并没有什么用？？ (有些编译器可能会初始化为0，但是C++标准并没有规定)

解答：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类型，如：int/char...，自定义类型就是我们使用class/struct/union等自己定义的类型，看看

下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认构造函数。

让让我们看看以下这个代码：

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

private:
	int _a;
};


class Date
{
public:
	// 我们没写，有没有构造函数？有->编译器自动生成
	// 内置类型/基本类型 int/char/double.../指针 
	// 自定义类型       class/struct...
	// 编译器自动生成构造函数，对于内置类型成员变量，没有规定要不要做处理！(有些编译器会处理)
	//                       对于自定义类型成员变量才会调用他的无参构造
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}

private:
	int _year; // 年
	int _month; // 月
	int _day; // 日

	A _aa;
};


int main()
{
	Date d1;
	d1.Print();

	return 0;
}

开始运行图：这些都是编译器给的随机值

结束运行图：编译器对自定义类型成员变量去调用它的无参构造 ，对内置类型不做处理，当你编译器跑出了随机值或者0，也不要奇怪，不同编译器不同实现。

总结：如果在Time这个类中如果没有Time()成员函数初始化赋值，那继续像类Date这样自定义一个类型，那他会继续调用下一个自定义类的默认构造函数，如果后面的类还有，那么他就会不断查找下去，直到最后内置类型有初始化了，或者说没有自定义类型了。
总结一句话：自定义类型的终点还是内置类型
我们没写，有没有构造函数？有，编译器自动生成，内置类型/基本类型 int/char/double.../指针 ，对于自定义类型 class/struct...编译器自动生成构造函数，对于内置类型成员变量，没有规定要不要做处理！(有些编译器会处理)
对于自定义类型成员变量才会调用他的无参构造

我们再看这个代码：

class Time
{
public:
	Time()
	{
		cout << "Time()" << endl;
		_hour = 0;
		_minute = 0;
		_second = 0;
	}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
private:
	// 基本类型(内置类型)
	int _year;
	int _month;
	int _day;
	// 自定义类型
	Time _t;
};
int main()
{
	Date d;
	return 0;
}

对于内置数据类型的成员变量,它们在默认构造函数中不会被初始化,所以它们的值是未定义的,也就是随机值。而对于自定义类型的成员变量,编译器会调用它们的默认构造函数来初始化,但是如果这个自定义类型也没有定义默认构造函数,那么它的成员变量也会是未定义的值，像Time()构造函数中，我们给他的成员初始化为0。

注意：C++11中针对内置类型不初始化的缺陷，有打了补丁，即：内置类型成员变量在类中声明可以给默认值。

class Time
{
public:
	Time()
	{
		cout << "Time()" << endl;
		_hour = 0;
		_minute = 0;
		_second = 0;
	}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
private:
	// 基本类型(内置类型)
	int _year = 1970;
	int _month = 1;
	int _day = 1;
	// 自定义类型
	Time _t;
};
int main()
{
	Date d;
	return 0;
}

这个给默认值不叫初始化，叫做给缺省值，因为在类中，内置类型里的这些是声明，不是定义，没有分配内存空间，所以不能赋值初始化。

小提示：

这里当我们调试时，按下F11它是直接跳转到time()的成员内部，那中间的内置类型不过一遍吗？因此我们再稍微改改，看看以下代码：

class Time
{
public:
	Time(int hour = 1, int minute = 1, int second = 1)
	{
		cout << "Time()" << endl;
		_hour = hour;
		_minute = minute;
		_second = second;
	}
private:
	int _hour = 9;
	int _minute = 8;
	int _second = 7;
};

动态调试图：

这里我们看到他并不是跳过内置类型，然后直接调用自定义类型，真正过程是略过一下内置类型，然后在构造函数中用参数覆盖了内置类型的值。

那自动生成的构造函数意义何在？编译器生成的默认构造函数确实没有什么用,因为它并不会初始化类的成员变量。

如果在Time这个类中如果没有Time()成员函数初始化赋值，那继续像类Date这样自定义一个类型，那他会继续调用下一个自定义类的默认构造函数，如果后面的类还有，那么他就会不断查找下去，直到最后内置类型有初始化了，或者说没有自定义类型了。
总结一句话：自定义类型的终点还是内置类型

🌉三种默认构造函数

无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。

class Date
{
public:
	Date()
	{
		_year = 1900;
		_month = 1;
		_day = 1;
	}
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
// 以下测试函数能通过编译吗？
int Test()
{
	Date d1;

	return 0;
}

这段代码不能通过编译。编译器会报错 "C2668: 'Date::Date': 对重载函数的调用不明确"。

出现这个错误的原因是,在 main() 函数中,当创建 Date d1 对象时,编译器无法确定应该调用哪个构造函数。

这是因为 Date() 构造函数和 Date(int, int, int) 构造函数都可以匹配 Date d1 的初始化,编译器无法确定应该调用哪个构造函数，产生调用歧义。因此我们可以使用一个即可，用的比较多的是这种全缺省构造函数：

Date(int year = 1900, int month = 1, int day = 1)
 {
 _year = year;
 _month = month;
 _day = day;
 }

实践中总结:

1、一般情况构造函数都需要我们自己显示的去实现

2、只有少数情况下可以让编译器自动生成构造函数

类似MyQueue，成员全是自定义类型

---

🚩总结