C++构造函数初步解析

        在c++中有六个默认的成员函数，分别是构造函数，析构函数， 拷贝构造函数 ， 赋值运算符重载 ，const成员函数 ，取地址及const取地址操作符重载。默认成员函数是指在一个类中，如果用户没有显式实现，编译器会自动生成的成员函数称为默认成员函数，即使是一个空类，也会自动实现。而构造函数是其中最常用的一个，现在我们让开始学习（本节需要有一点类的基础）。

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

看例子：

#include<iostream>
using namespace std;
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 d1(2023, 11, 4);
	d1.Print();
}

运行结果：

从中我们可以看到：通过构造函数，我们可以在创建对象时快捷的为成员变量赋值。

二. 特性：

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

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

其中我们主要讲解第四点，看例子：

  class Date
 {
  public:
      // 1.无参构造函数
      Date()
     {
        _year = 1900;
		_month = 1;
		_day = 1;
     }
  
      // 2.带参构造函数
      Date(int year, int month, int day)
     {
          _year = year;
          _month = month;
          _day = day;
     }
  private:
      int _year;
      int _month;
      int _day;
 };
  
  void TestDate()
 {
      Date d1; // 调用无参构造函数
      Date d2(2015, 1, 1); // 调用带参的构造函数
 }

构造函数重载时，编译器会根据其传入的参数类型，个数，及顺序选择适配的构造函数为对象赋值，如果找不到适配的那么编译器会报错。上面代码还有个细节，调用无参构造函数时要写成 Date d1,而不能写成Date d1()。        原因是写成Date d1(),会让编译器误解为你在声明一个返回类型为Data，函数名为d1,形参为空的函数，引起误解。

特别注意的是：一旦用户显式定义任何一个构造函数，编译器将不再生成默认构造函数。

三.默认构造函数

编译器自动生成的构造函数会完成什么功能呢？我们一起看看。

#include<iostream>
// std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中
using namespace std;
class Date
{
public:
//不写构造函数，编译器会生成默认构造函数

	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	d1.Print();
}

运行结果：

可以看到编译器生成的构造函数，只是将d1的成员变量赋为随机值。在这里看来默认构造函数没什么作用，那我们在看一个例子：

#include<iostream>
// std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中
using namespace std;
class Time
{
public:
	Time()
	{
		cout << "Time()" << endl;
		_hour = 0;
		_minute = 0;
		_second = 0;
	}
	Time(int hour,int minute,int second)
	{
		_hour = hour;
		_minute = minute;
		_second = second;
	}
	int _hour;
	int _minute;
	int _second;
};
class Date
{
public:
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day <<"    " << _t._hour<<" " << _t._minute<<" " << _t._second;
	}
private:
		// 基本类型(内置类型)
		int _year;
		int _month;
		int _day;
		// 自定义类型
		Time _t;

};


int main()
{
	Date d1;
	d1.Print();
	return 0;
}

在上面代码中：我们新增了一个Time类，并在Date类中新增了一个Time类型的变量，不写Date类的构造函数，使用编译器生成的默认构造，让我们看看d1不同成员变量的值

运行结果： 

可以看到Data中int类型的成员变量依旧是随机值，而对于Time类型的成员变量调用了他的无参构造方法进行赋值，从中我们可以得出以下结论：

1.对于基本类型(也叫内置类型)（也就是int，double,float等编译器自己定义的类型)的成员变量，当调用编译器生成的默认构造函数时一般会被赋值为随机值（但也有一些编译器会根据类型赋一些特定值，如将int 类型的赋值为0，不过大多数编译器都是随机值）。

2.对于自定义类型（如上面的Time）的成员变量,当调用这个类型所处的类的编译器生成默认构造函数时，会自动调用这个自定义成员变量内部的默认构造（有三种：无参构造，编译器自动生成的默认构造，全缺省构造）（可以这样认为，因为我们没有给这个成员变量的构造函数传入参数，所以调用的是不用传参构造函数，即默认构造）。

四.初始化列表:

private:
		// 基本类型(内置类型)
		int _year;
		int _month;
		int _day;
		// 自定义类型
		Time _t;

在上面的例子中有这样一段代码，其是对成员变量的声明，但是像引用，const修饰的变量，其在声明的时候必须赋值进行初始化，这时候我们就必须使用到初始化列表。（注意的是构造函数只是对成员变量进行了赋值，因为初始化只能初始化一次，而构造函数体内可以多次赋值）

总体来说有三种成员变量是一定要写进初始化列表分别是：1.引用成员变量     2.const成员变量   3.没有默认构造函数自定义类型成员(此时调用不了默认构造函数，只能放入初始化列表进行传参调用非默认构造函数)

使用格式：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。

看例子：

class Date
{
public:
Date(int year, int month, int day)

     : _year(year)
     , _month(month)
     , _day(day)
{

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

我们可能会好奇，没有放入初始化列表的其他变量编译器会怎么处理，看例子：

#include<iostream>
using namespace std;
class Time
{
public:
	Time()
	{
		cout << "Time()" << endl;
		_hour = 0;
		_minute = 0;
		_second = 0;
	}
	Time(int hour,int minute,int second)
	{
		_hour = hour;
		_minute = minute;
		_second = second;
	}
	int _hour;
	int _minute;
	int _second;
};
class Date
{
public:
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day <<"    " << _t._hour<<" " << _t._minute<<" " << _t._second;
	}
	Date(int year)
		: _year(year)
	{

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

};


int main()
{
	Date d1(1);
	d1.Print();
	cout << endl;

}

运行结果：

可以看到当其他成员变量未在自定义的构造函数的自定义列表里，对于内置类型一般生成随机值，对于自定义类型会调用默认构造（没有的话会报错），这个和系统自动生成的构造函数很相似。

一般的类型的可以放入初始列表也可以放入构造函数的函数体，但三种特殊的类型必须放入初始化列表。如

class A
{
public:
 A(int a)
 :_a(a)
 {}
private:
 int _a;
};
class B
{
public:
 B(int a, int ref)
 :_aobj(a)
 ,_ref(ref)
 ,_n(10)
 {}
private:
 A _aobj;  // 没有默认构造函数
 int& _ref;  // 引用
 const int _n; // const 
};

此外要注意：1.每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)

 2.成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关。

看看下面的题目：

class A
{
public:
    A(int a)
       :_a1(a)
       ,_a2(_a1)
   {}
    
    void Print() {
        cout<<_a1<<" "<<_a2<<endl;
   }
private:
    int _a2;
    int _a1;
};
int main() {
    A aa(1);
    aa.Print();
}

有四个选项：A. 输出1  1    B.程序崩溃     C.编译不通过     D.输出1  随机值

正确答案：D，因为初始化顺序是按成员变量的声明的顺序进行和初始化列表中的顺序无关，先用未进行赋值的_a1（未进行赋值的变量为随机值）给_a2赋值，再用传入的1给_a1赋值。故答案为D。

好了，构造函数讲解到此，有错误和和不解可以在评论区指出，谢谢读到这里了。