• C++构造函数

    构造函数详解

    类的6个默认的成员函数:

    类中如果什么都没有定义:---有六个默认的成员函数:

    1. 构造函数:主要完成对象的初始化工作
    2. 析构函数:主要完成对象中资源的清理工作
    3. 拷贝构造函数:拷贝一个新的对象
    4. 赋值运算符重载: 让两个对象之间进行赋值
    5. 引用的重载:普通和const类型--->对对象进行引用
    6. 如果类中没有显式定义(程序员没有定义)，编译器会宫动豳成一个默认的,构造函数

    构造函数的概念：

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

    构造函数的特性

    • 函数名与类名相同。
    • 无返回值。
    • 编译器自动调用对应的构造函数。
    • 构造函数可以重载。

    为什么要引出构造函数这一概念

    • 看下面的代码，对于Date类，可以通过InitDate公有的方法给对象设置内容，但是如果每次创建对象都调用该方法设置信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？
    • 现在我们的需求就是不通过对象去调用初始化对象的数据，我们希望当这个对象创建出来的时候，他就已经是具有一定的初始值的，那么如何做到我们现在的这个需求的呢？
    • 由此，引入了构造函数这一个概念，如下所示：
    1. #include
    2. using namespace std;
    3. class Date
    4. {
    5. public:
    6. 	void InitDate(int year, int month, int day)   //进行初始化的操作
    7. 	{
    8. 		_year = year;
    9. 		_month = month;
    10. 		_day = day;
    11. 	}
    12. 	void PrintDate()   //打印进行检测
    13. 	{
    14. 		cout << _year << "/" << _month << "/" << _day << endl;
    15. 	}
    16. private:
    17. 	int _year;
    18. 	int _month;
    19. 	int _day;
    20. };
    21.  
    22. int main()
    23. {
    24. 	Date d1, d2, d3;
    25.  
    26. 	d1.InitDate(2020, 4, 30);
    27. 	d1.PrintDate();
    28.  
    29. 	d2.InitDate(2020, 4, 29);
    30. 	d2.PrintDate();
    31.  
    32. 	d3.InitDate(2020, 4, 28);
    33. 	d3.PrintDate();
    34. }

    构造函数的功能

    • 需要注意的一点是，虽然构造函数叫"构造"函数，但是构造函数并不是用来构造对象的，构造函数的功能是用来完成对象的初始化的.
    1. #include
    2. using namespace std;
    3. class Date
    4. {
    5. public:
    6. 	//无参的构造函数
    7. 	Date()   //构造函数  ，没有返回值
    8. 	{
    9. 		cout << "Date()" << this << endl;   //打印this是为了看当前构造的是哪一个对象
    10. 		//把对象的地址打印出来
    11. 	}
    12. 	Date(int year, int month, int day)
    13. 	{
    14. 		_year = year;
    15. 		_month = month;
    16. 		_day = day;
    17. 	}
    18. 	//两个构造函数形成了重载
    19. 	//一个是没有参数的构造函数，一个是具有三个参数的构造函数 
    20.  
    21. 	//创建几个对象，编译器就会调用几次构造函数
    22. 	//调用构造函数的次数与对象的次数是相同的
    23. 	//因为构造函数调用的时机就是在创建对象的时候调用
    24. 	void InitDate(int year, int month, int day)   //进行初始化的操作
    25. 	{
    26. 		_year = year;
    27. 		_month = month;
    28. 		_day = day;
    29. 	}
    30. 	void PrintDate()   //打印进行检测
    31. 	{
    32. 		cout << _year << "/" << _month << "/" << _day << endl;
    33. 	}
    34. private:
    35. 	int _year;
    36. 	int _month;
    37. 	int _day;
    38. };
    39.  
    40. int main()
    41. {
    42. 	Date d1, d2, d3;
    43. 	Date d4(2020, 4, 27);
    44. 	Date d5();     
    45. 	//并不是创建了一个对象
    46. 	//这是一个函数声明，相当于我是有一个函数名称
    47. 	//为d5的函数，这个函数的返回值类型是Date类型，没有参数
    48.  
    49.  
    50. 	d1.InitDate(2020, 4, 30);
    51. 	d1.PrintDate();
    52.  
    53. 	d2.InitDate(2020, 4, 29);
    54. 	d2.PrintDate();
    55.  
    56. 	d3.InitDate(2020, 4, 28);
    57. 	d3.PrintDate();
    58.  
    59. 	d4.PrintDate();
    60.  
    61. }

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

    • 当然，前提是，只有用户没有显示定义构造函数的时候，编译器才会去生成默认的构造函数
    1. #include
    2. using namespace std;
    3. class Date
    4. {
    5. public:
    6. 	//无参的构造函数
    7. 	//Date()   //构造函数  ，没有返回值
    8. 	//{
    9. 	//	cout << "Date()" << this << endl;   //打印this是为了看当前构造的是哪一个对象
    10. 	//	//把对象的地址打印出来
    11. 	//}
    12. 	//Date(int year, int month, int day)
    13. 	//{
    14. 	//	_year = year;
    15. 	//	_month = month;
    16. 	//	_day = day;
    17. 	//}
    18. 	//两个构造函数形成了重载
    19.  
    20. 	//创建几个对象，编译器就会调用几次构造韩素
    21. 	void InitDate(int year, int month, int day)   //进行初始化的操作
    22. 	{
    23. 		_year = year;
    24. 		_month = month;
    25. 		_day = day;
    26. 	}
    27. 	void PrintDate()   //打印进行检测
    28. 	{
    29. 		cout << _year << "/" << _month << "/" << _day << endl;
    30. 	}
    31. private:
    32. 	int _year;
    33. 	int _month;
    34. 	int _day;
    35. };
    36.  
    37. int main()
    38. {
    39. 	Date d1;
    40. 	//编译器生成的构造函数是默认的构造函数
    41. 	//默认的构造函数一定是无惨的
    42. 	//如果说，用户定义构造函数了，编译器就不会生成的
    43. 	//如果这个时候再创建一个带有三个参数的对象的话
    44. 	//就一定是不会创建成功的
    45. 	//对象创建成功了，就说明是有默认的构造函数存在的
    46. 	return 0;
    47. }

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

    1. #include
    2. using namespace std;
    3. class Date
    4. {
    5. public:
    6. 	//无参的构造函数
    7. 	Date()   //构造函数  ，没有返回值
    8. 	{
    9. 		cout << "Date()" << this << endl;   //打印this是为了看当前构造的是哪一个对象
    10. 		//把对象的地址打印出来
    11. 	}
    12.  
    13. 	//全缺省的构造函数
    14. 	Date(int year=2000, int month=1, int day=1)
    15. 	{
    16. 		_year = year;
    17. 		_month = month;
    18. 		_day = day;
    19. 	}
    20. 	//两个构造函数形成了重载
    21.  
    22. 	//创建几个对象，编译器就会调用几次构造函数
    23. 	void InitDate(int year, int month, int day)   //进行初始化的操作
    24. 	{
    25. 		_year = year;
    26. 		_month = month;
    27. 		_day = day;
    28. 	}
    29. 	void PrintDate()   //打印进行检测
    30. 	{
    31. 		cout << _year << "/" << _month << "/" << _day << endl;
    32. 	}
    33. private:
    34. 	int _year;
    35. 	int _month;
    36. 	int _day;
    37. };
    38.  
    39. int main()
    40. {
    41. 	Date d1;
    42. }

    上面的代码，是会报错的，无法通过编译，报错的内容是—“Date::Date”:对重载函数的调用不明确，因为上面的代码中，有两个默认的构造函数，因为不带参数的构造函数和全缺省的构造函数都被看为默认的构造函数，所以说，现在有两个构造函数，编译器不知道到底要去调用哪个构造函数，所以说，就会报错，所以说，默认的构造函数只能存在有一个，下面的代码就可以通过编译了:

    1. #include
    2. using namespace std;
    3. class Date
    4. {
    5. public:
    6. 	//全缺省的构造函数
    7. 	Date(int year = 2000, int month = 1, int day = 1)
    8. 	{
    9. 		_year = year;
    10. 		_month = month;
    11. 		_day = day;
    12. 	}
    13. 	//两个构造函数形成了重载
    14.  
    15. 	//创建几个对象，编译器就会调用几次构造函数
    16. 	void InitDate(int year, int month, int day)   //进行初始化的操作
    17. 	{
    18. 		_year = year;
    19. 		_month = month;
    20. 		_day = day;
    21. 	}
    22. 	void PrintDate()   //打印进行检测
    23. 	{
    24. 		cout << _year << "/" << _month << "/" << _day << endl;
    25. 	}
    26. private:
    27. 	int _year;
    28. 	int _month;
    29. 	int _day;
    30. };
    31.  
    32. int main()
    33. {
    34. 	Date d1;
    35. }

      关于编译器生成的默认成员函数，很多人会有疑惑：在我们不实现构造函数的情况下，编译器会生成默认的构造函数。但是看起来默认构造函数又没什么用？d对象调用了编译器生成的默认构造函数，但是d对象year/month/_day，依旧是随机值。也就说在这里编译器生成的默认构造函数并没有什么用？

    • 解答：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语法已经定义好的类型：如int/char…，自定义类型就是我们使用class/struct/union自己定义的类型，看看下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员函数
    1. class Time
    2. {
    3. public:
    4. 	Time()
    5. 	{
    6. 		cout << "Time()" << endl;
    7. 		_hour = 0;
    8. 		_minute = 0;
    9. 		_second = 0;
    10. 	}
    11. private:
    12. 	int _hour;
    13. 	int _minute;
    14. 	int _second;
    15. };
    16. class Date
    17. {
    18. private:
    19. 	// 基本类型(内置类型)
    20. 	int _year;
    21. 	int _month;
    22. 	int _day;
    23. 	// 自定义类型
    24. 	Time _t;
    25. };
    26. int main()
    27. {
    28. 	Date d;
    29. 	return 0;
    30. }

    成员变量的命名风格 

    1. // 我们看看这个函数，是不是很僵硬？
    2. class Date
    3. {
    4. public:
    5. 	Date(int year)
    6. 	{
    7. 		// 这里的year到底是成员变量，还是函数形参？
    8. 		year = year;
    9. 	}
    10. private:
    11. 	int year;
    12. };
    13. // 所以我们一般都建议这样
    14. class Date
    15. {
    16. public:
    17. 	Date(int year)
    18. 	{
    19. 		_year = year;
    20. 	}
    21. private:
    22. 	int _year;
    23.  
    24. };
    25. // 或者这样。
    26. class Date
    27. {
    28. public:
    29. 	Date(int year)
    30. 	{
    31. 		m_year = year;
    32. 	}
    33. private:
    34. 	int m_year;
    35. };
    36. // 其他方式也可以的，主要看公司要求。一般都是加个前缀或者后缀标识区分就行。

    再谈构造函数

    问题：构造函数体中的语句是不是初始化？

    • 赋值和初始化的区别----赋值是可以进行多次赋值的，但是初始化的话，只能进行一次的初始化操作
    • 可以通过如下的方式进行验证，验证到底是初始化还是赋值

    • 发现上述的代码编译成功了，所以说明构造函数体中不是初始化，而是赋值

    • 上述代码中a为const类型的变量，对代码进行编译之后，发现代码无法通过编译，也就更加证实了，构造函数体内是赋值而并非是初始化，因为const类型的成员无法进行赋值的操作

    构造函数体赋值

    • 在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值
    • 构造函数最主要是用来完成对象的初始化的工作的，但是我们在构造函数函数体内进行的赋值操作虽然说也可以把给参数的值放到对象里面去，但是构造函数函数体里面不是初始化，因为是赋值操作，那么我们如何来判断构造函数函数体里面是赋值还是初始化呢？我们可以使用一个在定义的时候必须进行初始化的东西来判断构造函数函数体里面到底是赋值还是初始化。那么很容易想到的就是引用在定义的时候必须进行初始化操作，那么我们可以在private定义的变量中引入一个引用变量，给了引用变量之后是会报错的，那么就说明构造函数函数体里面的操作其实是赋值而不是初始化的操作
    1. class Date
    2. {
    3. public:
    4.     Date(int year, int month, int day)
    5.     {
    6.         _year = year;
    7.         _month = month;
    8.         _day = day;
    9.     }
    10. private:
    11.     int _year;
    12.     int _month;
    13.     int _day;
    14. };
    • 虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称作为类对象成员的初始化，构造函数体中的语句只能将其称作为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值
    • 所以得出结论—构造函数函数体中是赋值不是初始化

    初始化列表的概念 

    • 构造函数具有初始化列表，并且只有工造函数具有初始化列表，别的函数都没有初始化列表
    • 初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式
    1. #include
    2. using namespace std;
    3. class Date
    4. {
    5. public:
    6. 	Date(int year, int month, int day)
    7. 		:_year(year),
    8. 		_month(month),
    9. 		_day(day)
    10. 	{
    11. 		cout << "Date(int year, int month, int day)" << endl;
    12. 	}
    13. private:
    14. 	int _year;
    15. 	int _month;
    16. 	int _day;
    17. };

    • 那么如何验证初始化列表是初始化而不是赋值呢？
    • 因为我们是知道的，赋值是可以进行多次的，但是初始化只能初始化一次，那么我们就可以利用这个性质，在初始化列表中让一个变量出现多次，如果代码报错的话，那么就说明初始化列表是初始化而不是赋值了，如下所示，下面的代码时会报错的
    1. #include
    2. using namespace std;
    3. class Date
    4. {
    5. public:
    6. 	Date(int year, int month, int day)
    7. 		:_year(year),
    8. 		_month(month),
    9. 		_day(day),
    10. 		_day(day)
    11. 	{
    12. 		cout << "Date(int year, int month, int day)" << endl;
    13. 	}
    14. private:
    15. 	int _year;
    16. 	int _month;
    17. 	int _day;
    18. };
    • 报错内容是_day已经初始化了 
    • 初始化只能初始化一次，如果多次进行初始化操作的话，代码就会报错
    • 就好像是一个人不能多次出生是一样的道理

    初始化列表的功能 

    • 初始化列表就是专门就是为了对类中各个成员变量进行初始化的操作，而初始化呢他不是可以初始化两次的，所以一个变量如果初始化两次的话就会出错。因为在对变量进行初始化的时候需要为变量开辟内存空间，如果已经为一个变量开辟了内存空间的话，就不需要为那个变量再次开辟内存空间了。 一个变量开辟两个空间肯定是有问题的
    • 初始化列表并没有规定各个变量出现的次序，就算初始化列表的次序和形参出现的次序是不一样的，代码也是不会报错的，所以说，初始化列表并没有强制规定参数的次序要和形参的次序是一样的。但是一般情况下不建议这么做,防止出现像这样的问题

      

    为什么month会是随机值呢，因为编译器先去初始化year，然后初始化year完成之后，编译器开始去初始化month，但是初始化列表给的是用day去初始化month，但是此时day并没有进行初始化的操作，所以最终看出，month为随机值。

    注意事项

    • (1)初始化列表中成员的出现次序，不代表其真正的初始化次序
    • (2)成员变量在初始化列表中的初始化次序为其在类中的声明次序
    • 建议：最好不要使用成员初始化成员
    • 虽然说我们可以把_day写在_month的前面，但是我们在初始化的时候，还是先去初始化的_month然后再去初始化的_day
    • 编译器是不会按照我们所给出的初始化的顺序来进行初始化的，编译器是按照形参出现的顺序来进行初始化操作的

     拷贝构造函数也可以有初始化列表

    1. #include
    2. using namespace std;
    3. class Date
    4. {
    5. public:
    6. 	Date(const Date& d)
    7. 		: _year(d._year)
    8. 		, _month(d._month)
    9. 		, _day(d._day)
    10. 	{
    11. 		// 		_year = d._year;
    12. 		// 		_month = d._month;
    13. 		// 		_day = d._day;
    14. 		cout << "Date(Date&):" << this << endl;
    15. 	}
    16. private:
    17. 	int _year;
    18. 	int _month;
    19. 	int _day;
    20. };
    21.

    引用变量以及const类型的变量的注意事项 

    • 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
    • 类中包含以下成员，必须放在初始化列表位置进行初始化：(在构造和拷贝构造的地方都需要进行初始化)
    • (1)引用成员变量
    • (2)const成员变量

    1. #include
    2. using namespace std;
    3. class Date
    4. {
    5. public:
    6. #if 0
    7. 	// 初始化列表
    8. 	Date(int year = 1900, int month = 1, int day = 1)
    9. 		: _year(year)
    10. 		, _month(month)
    11. 		, _day(day)
    12. 	{
    13. 		// 构造函数体中是赋初值不是初始化
    14. // 		_year = year;
    15. // 		_month = month;
    16. // 		_day = day;
    17. 		//r = _day;
    18. 		cout << "Date(int,int,int):" << this << endl;
    19. 	}
    20. #endif
    21.  
    22. 	// 初始化列表
    23. 	// 1. 初始化列表中成员的出现次序，不代表其真正的初始化次序
    24. 	// 2. 成员变量在初始化列表中的初始化次序为其在类中的声明次序
    25. 	// 建议：最好不要使用成员初始化成员
    26. 	Date(int year = 1900, int month = 1, int day = 1)
    27. 		: _year(year)
    28. 		, _month(month)
    29. 		, _day(day)
    30. 		, _r(_day)
    31. 		, _a(_day)
    32. 	{
    33. 		// 构造函数体中是赋初值不是初始化
    34. 		// 		_year = year;
    35. 		// 		_month = month;
    36. 		// 		_day = day;
    37. 		//r = _day;
    38. 		cout << "Date(int,int,int):" << this << endl;
    39. 	}
    40.  
    41. 	Date(const Date& d)
    42. 		: _year(d._year)
    43. 		, _month(d._month)
    44. 		, _day(d._day)
    45. 		, _r(d._r)
    46. 		, _a(d._a)
    47. 	{
    48. 		// 		_year = d._year;
    49. 		// 		_month = d._month;
    50. 		// 		_day = d._day;
    51. 		cout << "Date(Date&):" << this << endl;
    52. 	}
    53.  
    54. 	// d1 = d2 = d3;
    55. 	Date& operator=(const Date& d)
    56. 	{
    57. 		cout << this << "=" << &d << endl;
    58. 		if (this != &d)
    59. 		{
    60. 			_year = d._year;
    61. 			_month = d._month;
    62. 			_day = d._day;
    63. 		}
    64.  
    65. 		return *this;
    66. 	}
    67.  
    68. 	~Date()
    69. 	{
    70. 		cout << "~Date():" << this << endl;
    71. 	}
    72.  
    73.  
    74. 	int _year;
    75. 	int _month;
    76. 	int _day;
    77. 	int& _r;
    78. 	const int _a;
    79. };
    • (3)类类型成员(该类没有默认构造函数)
    1. #include
    2. using namespace std;
    3. class Time
    4. {
    5. public:
    6. 	Time(int hour, int minute, int second)
    7. 		: _hour(hour)
    8. 		, _minute(minute)
    9. 		, _second(second)
    10. 	{}
    11.  
    12.  
    13. private:
    14. 	int _hour;
    15. 	int _minute;
    16. 	int _second;
    17. };
    18.  
    19. class Date
    20. {
    21. public:
    22. 	Date(int year = 1900, int month = 1, int day = 1)
    23. 		: _year(year)
    24. 		, _month(month)
    25. 		, _day(day)
    26. 		, _t(0, 0, 0)
    27. 		//, _t()   //调用无参的默认的构造函数
    28. 	{
    29. 		cout << "Date(int,int,int):" << this << endl;
    30. 	}
    31.  
    32. private:
    33. 	int _year;
    34. 	int _month;
    35. 	int _day;
    36. 	Time _t;
    37. 	//如果没有上面的_t(0, 0, 0)，直接给出Time_t是会报错的，原因在于
    38. 	//声明了一个time类的对象t，那么这个对象t一定是需要进行初始化的
    39. 	//那么编译器会默认去Time类中寻找没有参数的构造函数，但是Time类此时是没有
    40. 	//显示给出无参的构造函数的，所以就会出错
    41. 	//那么我们为了可以正确的创建出来这个Time类类型的对象的话，那么我们就需要给出来一个有参数的
    42. 	//就好比说_t(0, 0, 0)，就可通过编译了
    43. };
    44.  
    45. int main()
    46. {
    47. 	//Date d(2019, 3, 24);
    48. 	Date d;
    49. 	return 0;
    50. }
    • 尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。(没写并不代表没有，还是会去调用相应的函数的)
    • 其实也就是说，就算你的构造函数函数体里面什么都没有，他也是会优先去执行构造函数的初始化列表，所以，尽量还是使用初始化列表来进行初始化操作。
    • 调试起来的话，会首先停在构造函数函数名的位置上，并没有直接走到了函数体的内部
    • 看起来构造函数没有写初始化列表，但是需要注意，没有写并不代表没有，因为如果用户没有写的话，其实编译器是会自动去加上的，只不过一般情况下成员变量是用随机值进行初始化的
    • 要先初始化好，才能进入到构造函数的函数体中

     

    1. #include
    2. using namespace std;
    3. class Time
    4. {
    5. public:
    6. 	Time(int hour = 0, int minute = 0, int second = 0)
    7. 		: _hour(hour)
    8. 		, _minute(minute)
    9. 		, _second(second)
    10. 	{
    11. 		cout << this->_hour << endl;
    12. 	}
    13.  
    14. 	void TestFunc()
    15. 	{}
    16.  
    17. private:
    18. 	int _hour;
    19. 	int _minute;
    20. 	int _second;
    21. };
    22.  
    23. class Date
    24. {
    25. public:
    26. 	Date(int year = 1900, int month = 1, int day = 1)
    27. 		// 		: _year(year)
    28. 		// 		, _month(month)
    29. 		// 		, _day(day)
    30. 				//, _t()   //调用无参的默认的构造函数
    31. 	{
    32. 		cout << "Date(int,int,int):" << this << endl;
    33. 	}
    34.  
    35. private:
    36. 	int _year;
    37. 	int _month;
    38. 	int _day;
    39. 	Time _t;
    40. };

    • 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关,也就是说，不是按照我给的初始化列表的次序来进行初始化操作的，编译器是按照声明的次序来进行初始化的(上面已经提到过了)

    提问，在初始化列表中如何知道对象已经构造好了？ 

    • 就是在构造函数的初始化列表完成之后，去打印一下this，如果代码可以正常的通过编译，那么就说明我的对象是构造好了的
    1. #include
    2. using namespace std;
    3. class Time
    4. {
    5. public:
    6. 	Time(int hour = 0, int minute = 0, int second = 0)
    7. 		: _hour(hour)
    8. 		, _minute(minute)
    9. 		, _second(second)
    10. 	{
    11. 		cout << this<< endl;    //我的意图是要去打印this，然后发现代码可以正常通过编译
    12. 		//那么，也就是说，此时，我的对象已经构造好了
    13. 	}
    14. private:
    15. 	int _hour;
    16. 	int _minute;
    17. 	int _second;
    18. };

    两个问题

    在构造函数有没有把对象的地址传递过去呢？

    • 对象的地址一定是传递过来了的，如果对象的地址没有传递过来的话，那儿我怎么知道当前构造的是那个对象呢？所以说对象的地址一定是已经传递过来了的

    • 008560677 把t的首地址放到了exc寄存器里面，然后去调用Time类的函数
    • 在构造函数调用之前，对象是不存在的，因为构造函数的目的就是用来初始化对象的，虽然对象本身是并不存在的，但是对象的空间是存在的，所以也就是说，在我们没有调用构造函数之前，我们就已经有了一段空间了，因为编译器是要进行编译的，所以他必须提前计算出这个对象需要多大的栈空间

    • 定义了两个对象，所以编译器必须要在编译期间计算出这两个对象的大小，因为不可能做到一边运行一边修改，所以说，必须要提前计算好，在编译的时候是不会调用构造函数的，是在运行的时候去调用的

    在构造函数的初始化列表的位置可不可以使用this指针呢？ 

    • 在构造函数初始化列表的位置还不能使用构造函数，因为this是指向当前对象的，初始化列表的位置，当前对象还并没有构造好，所以还是不能使用的，还没有真正的区划分空间。但是在函数体里面是完全可以，因为对象已经完全的初始化完成了，是 可以正常去使用的
    1. #include
    2. using namespace std;
    3. class Time
    4. {
    5. public:
    6. 	Time(int hour = 0, int minute = 0, int second = 0)
    7. 		: _hour(hour)
    8. 		, _minute(minute)
    9. 		, _second(second)
    10. 	{
    11. 		cout << this->_hour << endl;
    12. 	}
    13.  
    14. 	void TestFunc()
    15. 	{}
    16.  
    17. private:
    18. 	int _hour;
    19. 	int _minute;
    20. 	int _second;
    21. };
    22.  
    23. class Date
    24. {
    25. public:
    26. 	Date(int year = 1900, int month = 1, int day = 1)
    27. 		// 		: _year(year)
    28. 		// 		, _month(month)
    29. 		// 		, _day(day)
    30. 				//, _t()   //调用无参的默认的构造函数
    31. 	{
    32. 		cout << "Date(int,int,int):" << this << endl;
    33. 	}
    34.  
    35. private:
    36. 	int _year;
    37. 	int _month;
    38. 	int _day;
    39. 	Time _t;
    40. };
    41.  
    42. int main()
    43. {
    44. 	// 在编译器编译期间，已经为main分配好了栈空间
    45. 	// 该空间中已经包含了函数体中的局部对象
    46. 	Date d;    // 在构造函数调用之前，对象是不存在的
    47. 	Time t;
    48. 	t.TestFunc();
    49.  
    50. 	return 0;
    51. }

    结论：也就是说对象的空间早就已经给好了，只不过缺的是构造函数，构造函数的功能就是把对象中各个成员变量给其初始化好就可以了

    构造函数的功能:

    • 构造函数不仅就有初始化成员变量的功能，还具有类型转化的功能

    • 因为单参的构造函数代码可读性太差，所以我们一般就把单参的构造函数的类型转换的功能给他禁止掉，用下面的关键字进行禁止

    explicit关键字 

    • 构造函数不仅可以构造与初始化对象，对于单个参数的构造函数，还具有类型转换的作用

    1. #include
    2. using namespace std;
    3. class Date
    4. {
    5. public:
    6. 	Date(int year)
    7. 		: _year(year)
    8. 	{
    9. 		cout << "Date(int,int,int):" << this << endl;
    10. 	}
    11.  
    12. 	Date& operator=(const Date& d)
    13. 	{
    14. 		return *this;
    15. 	}
    16.  
    17. private:
    18. 	int _year;
    19. 	int _month;
    20. 	int _day;
    21. };
    22.  
    23.  
    24. int main()
    25. {
    26. 	Date d(2019);
    27. 	d = 2020;   
    28. 	//一个是日期类型的变量，一个是整形的变量，在我们之前想的是，这时不能通过编译的
    29. 	//但是没想到，这样的代码是可以通过编译的，原因在于
    30. 	// 2020---> 通过单参构造函数--->临时对象
    31. 	//也就是说构造函数具有类型转换的功能，本来是一个int类型，然后被转换了
    32. 	// 用一个整形变量给日期类型对象赋值
    33. 	// 实际编译器背后会用2020构造一个无名对象，最后用无名对象给d1对象进行赋值
    34. 	//但是一般情况下，会把这种类型转换禁止掉，那么如何来禁止呢？
    35. 	//禁止的方法就是在构造函数前面加上一个explicit关键字
    36. 	return 0;
    37. }
    • 上述代码可读性不是很好，用explicit修饰构造函数，将会禁止单参构造函数的隐式转换。
    1. #include
    2. using namespace std;
    3. class Date
    4. {
    5. public:
    6. 	explicit Date(int year)
    7. 		: _year(year)
    8. 	{
    9. 		cout << "Date(int,int,int):" << this << endl;
    10. 	}
    11.  
    12. 	Date& operator=(const Date& d)
    13. 	{
    14. 		return *this;
    15. 	}
    16.  
    17. private:
    18. 	int _year;
    19. 	int _month;
    20. 	int _day;
    21. };
    22.  
    23.  
    24. int main()
    25. {
    26. 	Date d(2019);
    27. 	d = 2020;   // 2020---> 通过单参构造函数--->临时对象
    28. 	return 0;
    29. }

    之前说过的几个默认的构造函数，如果我么没有显示给出的话，编译器会生成默认的 

    1. #include
    2. using namespace std;
    3. class Date
    4. {
    5. private:
    6. 	int _year;
    7. 	int _month;
    8. 	int _day;
    9. };
    10. int main()
    11. {
    12. 	Date d;
    13. 	return 0;
    14. }
    • 问题来了，什么时候编译器会生成默认的？-------答案就是—>如果编译器感觉自己需要的时候就会生成，那么问题又来了，什么才是编译器需要的时候(一共有四种场景)
    1. #include
    2. using namespace std;
    3. class Time
    4. {
    5. public:
    6. 	Time(int hour = 0, int minute = 0, int second = 0)
    7. 		: _hour(hour)
    8. 		, _minute(minute)
    9. 		, _second(second)
    10. 	{
    11. 		cout << this->_hour << endl;
    12. 	}
    13.  
    14. 	Time(Time&)
    15. 	{}
    16.  
    17. 	Time& operator=(Time& t)
    18. 	{
    19. 		return *this;
    20. 	}
    21.  
    22. 	~Time()
    23. 	{}
    24.  
    25. private:
    26. 	int _hour;
    27. 	int _minute;
    28. 	int _second;
    29. };
    30.  
    31. class Date
    32. {
    33. public:
    34. 	// 	Date()
    35. 	// 	{}
    36.  
    37. 		/*
    38. 		Date(Date& d)
    39. 		   : _t(d._t)
    40. 		{}
    42. 		*/
    43.  
    44. private:
    45. 	int _year;
    46. 	int _month;
    47. 	int _day;
    48. 	Time _t;
    49. };
    50. int main()
    51. {
    52. 	Date d1; // 日期类的构造函数 // Time()
    53. 	Date d2(d1);  // Time(Time&)--->找个调用位置--->Date类的拷贝构造函数中
    54. 	Date d3;
    55. 	d3 = d1;
    56. 	return 0;
    57. }
    • (1)现在有A类和B类两个类，B类中包含A类的对象，A类中有缺省的构造函数，B类中没有定义任何的构造函数，编译器此时就会生成默认的构造函数
    • (2)Time(Time&)—>找个调用位置—>Date类的拷贝构造函数中
    • (3)赋值也是一样的

      谢谢大家的支持! 

  • 相关阅读:
    2023.11.14 关于 Spring Boot 创建和使用
    10【桥接设计模式】
    Gin：获取本机IP，获取访问IP
    超声波模块详细介绍（stm32循迹小车中超声波的介绍）
    【从零开始学习 SystemVerilog】7.11、SystemVerilog 类—— Shallow/Deep Copy（浅拷贝、深拷贝）
    centos7 快速搭建自测mysql环境 docker + mysql
    【Typescript】面向对象（上篇），包含类，构造函数，继承，super，抽象类
    Unity 小技巧积累
    day5ARM
    go 1.22 增强 http.ServerMux 路由能力
  • 原文地址：https://blog.csdn.net/wo_ai_luo_/article/details/127809998