构造函数的初始化列表，static成员，友元，内部类【类和对象（下）】

P. S.：以下代码均在VS2022环境下测试，不代表所有编译器均可通过。 P. S.：测试代码均未展示头文件stdio.h的声明，使用时请自行添加。

在这里插入图片描述

                        博主主页：LiUEEEEE
                          C++专栏
                        C语言专栏
                       数据结构专栏
                       排序算法专栏
                      力扣牛客经典题目专栏

1、构造函数的初始化列表

1.1 构造函数再回首

在我的往期博客

构造，析构，拷贝【类和对象（中）】
中提到过类的构造函数，以日期类为例，初始化的方式如下所示：

class Date
{
public:Date(int year, int month, int day){_year = year;_month = month;_day = day;}
private:int _year;int _month;int _day;
};

正如上述代码，在通常没有对C++进行进一步学习的情况下，使用者会认为构造函数中的代码就是对类成员变量的初始化，但事实恰恰相反，在C++中构造函数的主语句只是对成员变量进行赋值，并不能称为真正意义上的初始化，因为初始化只能初始化一次，而构造函数可以对成员变量多次赋值，例如：

	Date(int year, int month, int day){_year = year;_year += 1;}

1.2 初始化列表

此时就要引入C++中的初始化列表。
初始化列表是以“ ：”（冒号）开始，“ ，”（逗号）分割的数据成员列表，每个成员变量后面跟着一个括号，括号中所放值为初始化的值，例如：

	Date(int year, int month, int day): _year(year), _month(month), _day(day){}

需要注意的是：

每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
类中包含以下成员，必须放在初始化列表位置进行初始化：
- 引用成员变量
- 自定义类型成员变量（且该自定义类型没有默认构造函数：无参的构造函数，全缺省的构造函数，系统自动生成的构造函数）
- const修饰的成员变量

上述所提及的自定义成员变量（没有默认构造函数）是指，定义的自定义成员变量的构造函数为带参构造函数，需要传递参数才可以初始化，在使用者显示实现构造函数时，如果没有写出初始化列表，编译器会自动帮使用者生成，但自定义成员变量的初始化如果需要参数的参与时，系统不会默认传递参数，会导致未初始化，而上述注意事项就是为了避免未初始化的情况发生，以避免后续使用不必要麻烦。

1.3 初始化列表小tips

在编写初始化列表时，需将成员变量初始化顺序和类中声明顺序保持一致，因为编译器在初始化变量时时按照声明顺序进行依次初始化，如果使用者不按照顺序进行书写，会导致不必要麻烦，如：

class A
{
public:A(int n):_a2(n),_a1(_a2){}void Print(){cout << "_a1 = " << _a1 << endl;cout << "_a2 = " << _a2 << endl;}
private:int _a1;int _a2;
};int main()
{A aa(100);aa.Print();return 0;
}

在这里插入图片描述
在如上图所示初始化方式进行初始化时，就会达到与预期不符的结果，故使用时需避免此类操作的发生。

2、explicit关键字

对于构造函数，其还有一个功能是专对于单参数构造函数或多参数但第一个参数没有默认值的构造函数的隐式类型转换，例如：

class Date
{
public:Date(int year): _year(year){}Date& operator=(const Date& d){if (this != &d){_year = d._year;_month = d._month;_day = d._day;}return *this;}
private:int _year;int _month;int _day;
};

class Date
{
public:Date(int year, int month = 1, int day = 1): _year(year), _month(month), _day(day){}Date& operator=(const Date& d){if (this != &d){_year = d._year;_month = d._month;_day = d._day;}return *this;}
private:int _year;int _month;int _day;
};

当通过传递一个值赋值时，例如：

	Date date(2024);

在编译器层面，并不是直接将2024赋值给所创建的类对象，而是通过隐式转换将2024转化为一个临时的类对象，再通过此类对象赋值给需要初始化的类对象，例如，需要初始化的类对象为A，临时类对象为B：

	Date A(2024);等价于Date A = B//B的值为2024

而C++为了避免隐式转换的情况发生，创建了explicit关键字，在构造函数前加explicit即可防止隐式转换的发生，例如：

	explicit Date(int year): _year(year){}

3、static成员

3.1 static成员概念

声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化，例如：

class Date
{
public:Date(int year, int month = 1, int day = 1): _year(year), _month(month), _day(day){}
private:int _year;int _month;int _day;static int _i;
};int Date::_i = 1;

3.2 static成员特性

静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区
静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
类静态成员即可用类名::静态成员或者对象.静态成员来访问
静态成员函数没有隐藏的this指针，不能访问任何非静态成员
静态成员也是类的成员，受public、protected、private 访问限定符的限制

4、友元

友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。

友元分为：友元函数和友元类

4.1 友元函数

友元函数是指当类外的函数需要访问类中的私有成员时，可以在类中声明一下此函数时类的友元函数，便可访问，例如：

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

友元函数可访问类的私有和保护成员，但不是类的成员函数
友元函数不能用const修饰
友元函数可以在类定义的任何地方声明，不受类访问限定符限制
一个函数可以是多个类的友元函数
友元函数的调用与普通函数的调用原理相同

4.2 友元类

当一个类像访问另一个类的私有成员时，可以将此类作为友元声明在需要访问的类中，便可访问其私有成员，例如：

class Time
{friend class Date; // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类//中的私有成员变量
public:Time(int hour = 0, int minute = 0, int second = 0): _hour(hour), _minute(minute), _second(second){}
private:int _hour;int _minute;int _second;
};
class Date
{
public:Date(int year = 1900, int month = 1, int day = 1): _year(year), _month(month), _day(day){}	void SetTimeOfDate(int hour, int minute, int second){// 直接访问时间类私有的成员变量_t._hour = hour;_t._minute = minute;_t._second = second;}
private:int _year;int _month;int _day;Time _t;
};

友元关系是单向的，不具有交换性。比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。
友元关系不能传递，如果C是B的友元， B是A的友元，则不能说明C是A的友元。

5、内部类

C++支持在一个类的内部创建另一个类，后者就称之为内部类，内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。
且内部类天生就是外部类的友元，即内部类可以访问外部类的私有成员。

特性：

内部类可以定义在外部类的public、protected、private都是可以的。
注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
sizeof(外部类)=外部类，和内部类没有任何关系。

6、结语