类和对象（下）(1)

类和对象（下）

再探构造函数

• 我们之前在实现构造函数的时候，初始化成员变量使用的方式都是在函数体内进行赋值，其实构造函数初始化成员变量还有一种方式：初始化列表。

初始化列表不只是为了写得方便，还能解决很多的问题

初始化列表的使用方式：

Date(int& x,int year=1,int month=1,int day=1)
    :_year(year)
        ,_month(month)
        ,_day(day)
        ,_t_(12)
        ,_ref(x)
        ,_n(1)

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

• 每个成员变量在初始化列表中只能出现一次，语法理解上初始化列表可以认为是每个成员变量定义初始化的地方。（对象整体定义的时候会去调用构造函数，认为初始化列表就是每个成员变量定义的地方）

• 我们知道const类型的变量只有一次初始化的机会，这样的写法是不行的：

  const int x;
  x=1;
  

  必须在定义的时候初始化且以后无法改变它。

  所以const修饰的变量必须在初始化列表初始化而不能在函数体内初始化（普通的变量可以在初始化列表初始化也可以在函数体内初始化）。

• 除了const修饰变量必须在定义的时候（也就是在初始化列表）初始化，还有引用也是一样。因为我们知道引用也必须在定义的地方初始化，下面这样写是不行的：

  int& rx;
  

  上面几点的汇总：

  #include<iostream>
  using namespace std;
  
  class Date
  {
  public:
  	Date(int& xx,int year, int month, int day)
  		:_year(year)//括号里可以是表达式
  		, _month(month)
  		, _day(day)
  		,_n(1)
  		,_ref(xx)
  	{}
  
  	void Print() const
  	{
  		cout << _year << "-" << _month << "-" << _day << endl;
  	}
  
  private:
  	//声明
  	int _year;
  	int _month;
  	int _day;
      
      //必须在初始列表（定义的地方）初始化
  	const int _n;
  	int& _ref;
  };
  
  int main()
  {
  	int x = 0;
  	//对象整体的定义——对象整体定义的时候会去调用构造函数，认为初始化列表就是每个成员变量定义的地方
  	Date d1(x,2024, 8, 18);
  	d1.Print();
  
  	return 0;
  }
  

  • 还有一类成员变量：没有默认构造的类类型变量，也必须放在初始化列表位置进⾏初始化，否则会编译报错。

class Time
{
public:
	Time(int hour = 0)
		:_hour(hour)
	{
		cout << "Time()" << endl;
	}
private:
	int _hour;
};

class Date
{
public:
	Date(int& xx,int year, int month, int day)
		:_year(year)
		, _month(month)
		, _day(day)
		,_n(1)
		,_ref(xx)
	{}

	void Print() const
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}

private:
	//声明 
	int _year;
	int _month;
	int _day;

	//必须在初始列表（定义的地方）初始化
	const int _n;
	int& _ref;
    
	Time _t;
};

我们在Date中多加入了一个自定义类型成员变量_t，就算我们不写它的初始化，也会走初始化列表，去调用它的默认构造。

如果没有默认构造，我们就要这么写：

	Date(int& xx,int year, int month, int day)
		:_year(year)
		, _month(month)
		, _day(day)
		,_n(1)
		,_ref(xx)
		,_t(1)//就像构造一样去写
	{}

总结：引⽤成员变量，const成员变量，没有默认构造的类类型变量，必须放在初始化列表位置进⾏初始化，否则会编译报错

初始化列表和函数体内初始化的方式是可以混起来用的，其实有的情况还不得不混起来用，比如成员变量中有指针的情况：

Date(int& xx,int year, int month, int day)
	:_year(year)//括号里可以是表达式
	, _month(month)
	, _day(day)
	,_n(1)
	,_ref(xx)
	,_t(1)//就像构造一样去写
	,_ptr((int*)malloc(12))
{
	if (_ptr == nullptr)
	{
		perror("malloc fail!");
	}
	else
	{
		memset(_ptr, 0, 12);
	}
}

• 尽量使⽤初始化列表初始化，因为那些你不在初始化列表初始化的成员也会走初始化列表，如果这个成员在声明位置给了缺省值，初始化列表会用这个缺省值初始化。如果你没有给缺省值，对于没有显⽰在初始化列表初始化的内置类型成员是否初始化取决于编译器，C++并没有规定。对于没有显示在初始化列表初始化的自定义类型成员会调用这个成员类型的默认构造函数，如果没有默认构造会编译错误。

class Date
{
public:
	Date(int year, int month, int day)
		:_year(year)//括号里可以是表达式
		, _month(month)
		//这里_day的初始化我们不写，也会走初始化列表
	{}

	void Print() const
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}

private:
	//声明 
	int _year;
	int _month;
	int _day;

};

int main()
{
	int x = 0;
	Date d1(2024, 8, 18);
	d1.Print();

	return 0;
}

初始化列表是每个成员初始化定义的地方。有些变量也可以定义的时候不初始化，这不违反语法规则。所以_day的值我们说是“不确定的”，取决于编译器。

缺省值

C++11还有一种这样的写法：

private:
	//声明 
	int _year = 1;
	int _month = 1;
	int _day = 1;

但它还是声明，不是定义。定义的特点是开空间。这后面的是缺省值。

这个缺省值是给初始化列表用的。如果初始化列表写了就用初始化列表的，如果没写就用缺省值（也可以叫默认值）。

class Date
{
public:
	Date(int year, int month, int day)
		:_year(year)//括号里可以是表达式
		, _month(month)
	{}

	void Print() const
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}

private:
	//声明 
	int _year = 1;
	int _month = 1;
	int _day = 1;

};

int main()
{
	Date d1(2024,7,8);
	d1.Print();

	return 0;
}

不只是在我们自己写的构造函数中可以用到缺省值，在编译器自动生成的无参的构造函数中也会用到缺省值。以前我们编译器自动生成的构造函数对内置类型不做处理，对自定义类型取调用它的构造，而现在有了缺省值，即使自动生成的，也可以用缺省值来初始化了：

总结：

每个构造函数都有初始化列表，每个成员都要走初始化列表

1. 在初始化列表初始化的成员

2. 没有在初始化列表初始化的成员

   a. 声明的地方有缺省值用缺省值

   b.没有缺省值

   ​ x:内置类型，不确定是否初始化，看编译器，大概率随机值

   ​ y:自定义类型，调用默认构造，没有默认构造就编译报错

3. 引用、const、没有默认构造的自定义类型，这三种必须在初始化列表初始化

所以我们也可以看出来，尽量写初始化列表。

还有一个问题，形参的初始值和声明处写的缺省值是什么关系？不要混为一谈。

• 初始化列表中按照成员变量在类中声明顺序进行初始化，跟成员在初始化列表出现的的先后顺序无关。建议声明顺序和初始化列表顺序保持⼀致。

  例子：

#include<iostream>
using namespace std;

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

private:
     int _a2 = 2;
     int _a1 = 2;
};

int main()
{
     A aa(1);
     aa.Print();
}

答案为D

为什么初始化列表中按照成员变量在类中声明顺序进行初始化？这是因为声明的顺序其实就是它在内存中存放的顺序。

这些特性确实很复杂，我们可以多实践感受一下。

本文到此结束，类和对象（下）并未讲完，敬请期待后文=_=