C++ 类和对象（3）初始化列表、友元函数、内部类

再谈构造函数

构造函数体内赋值

当我们创建对象时，编译器会调用构造函数对对象中的成员变量进行赋值
例如：

class Date
{
public:// 构造函数Date(int year = 0, int month = 1, int day = 1){_year = year;_month = month;_day = day;}
private:int _year;int _month;int _day;
};

但是，上面的例子中，使用构造函数进行赋值，虽然使对象中的每个成员变量都有了一个初始值，但是在构造函数中的语句只能称作赋初值，而不能称为初始化。
原因： 因为初始化只能初始化一次，但是在构造函数体内可以进行多次赋值，例如我可以在函数体内中_year = 2025; 再次对_year进行赋值。因此构造函数中的语句不能称为初始化。

初始化列表

初始化列表的使用方式是以⼀个冒号开始，接着是⼀个以逗号分隔的数据成员列表，每个"成员变量"后⾯跟⼀个放在括号中的初始值或表达式
例如：

class Date
{
public:// 构造函数Date(int year = 0, int month = 1, int day = 1):_year(year), _month(month), _day(day){}
private:int _year;int _month;int _day;
};

初始化列表特点

1. 每个成员变量在初始化列表中只能出现⼀次，语法理解上初始化列表可以认为是每个成员变量定义初始化的地方，初始化只能进行一次，所以一个变量只能出现一次
2. 引用成员变量，const成员变量，没有默认构造的类类型变量（没有默认构造函数，所以需要进行传参），必须放在初始化列表位置进行初始化

// 引用成员变量
int a = 10;
int& b = a;// 创建时就初始化// const成员变量
const int a = 10;//正确 创建时就初始化
const int b;//错误 创建时未初始化// 没有默认构造的类类型变量
class A 
{
public:A(int val) //注：这个不叫默认构造函数（需要传参调用）{_val = val;}
private:int _val; // 这不是类类型变量
};class B
{
public:B():_a(2021) //必须使用初始化列表对其进行初始化{}
private:A _a; //自定义类型成员（该类没有默认构造函数）
};

默认构造函数：不用传参就可以调用的构造函数
1、不显式写，编译器会自动生成的构造函数
2、无参的构造函数
3、全缺省的构造函数

总结： 在定义时就必须进行初始化的变量类型，就必须放在初始化列表进行初始化。

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

注意：
对于内置类型，使用初始化列表和在构造函数体内进行初始化实际上是没有差别的，效果类似以下代码

// 使用初始化列表
int a = 10
// 在构造函数体内初始化（不使用初始化列表）
int a;
a = 10;

但是对于自定义类型，使用初始化列表可以提高效率
例如：

class Time
{
public:Time(int hour = 0){_hour = hour;}
private:int _hour;
};// 使用初始化列表
class Test
{
public:// 使用初始化列表Test(int hour):_t(12)// 调用一次Time类的构造函数{}
private:Time _t;
};// 未使用初始化列表
class Test
{
public:// 在构造函数体内初始化（不使用初始化列表）Test(int hour){ //初始化列表调用一次Time类的构造函数（不使用初始化列表但也会走这个过程）Time t(hour);// 调用一次Time类的构造函数_t = t;// 调用一次Time类的赋值运算符重载函数}
private:Time _t;
};

通过以上代码对比可知，首先明确不在初始化列表进行初始化的成员也会走初始化列表，即虽然没有在初始化列表进行初始化，也会根据成员变量调用一次Time类的构造函数。而如果不使用初始化列表，那么在函数体内会再次使用一次构造函数，接着还要使用赋值运算符重载，因此不使用初始化列表比使用初始化列表多了一次构造函数和一次赋值运算符重载

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

例子：

#include <iostream>
using namespace std;
int i = 0;
class Test
{
public:Test():_b(i++),_a(i++){}void Print(){cout << "_a:" << _a << endl;cout << "_b:" << _b << endl;}
private:int _a;int _b;
};
int main()
{Test t;t.Print(); //打印结果t._a为0，t._b为1return 0;
}

类中成员变量的顺序是a在前，b在后；初始化列表中的顺序是b在前，a在后。如果是根据初始化列表中的顺序进行初始化的话，结果应该是b为0，a为1；但是结果却是a为0，b为1，所以可以看出初始化顺序是根据成员变量的声明顺序进行的

初始化列表总结：
无论是否显示写初始化列表，每个构造函数都有初始化列表；
无论是否在初始化列表显示初始化，每个成员变量都要走初始化列表初始化；

类型转换

C++支持内置类型隐式转换为类类型对象，有相关内置类型为参数的构造函数即可

例如：

#include <iostream>
using namespace std;
class Date
{
public:Date(int year = 0) //单个参数的构造函数 相关内置类型为参数:_year(year){}
private:int _year;
};
int main()
{Date d1 = 2025; //支持该操作 将内置类型2021隐式转换为对象d1return 0;
}

代码Date d1 = 2025等价于以下代码：

Date tmp(2025); //先构造一个临时对象
Date d1(tmp); //再用该临时对象进行拷贝构造

上面的代码是在早期的编译器实现的转换，而现在的编译器进行了优化，是这样的

// 隐式类型转换
Date d1(2025);

但是，对于单参数的自定义类型来说，Date d1 = 2025这种代码的可读性不是很好，我们可以使用关键字explicit来修饰构造函数进行禁止隐式类型转换
例如：

class Date
{
public:explicit Date(int year = 0) //单个参数的构造函数:_year(year){}
private:int _year;
};

static成员

用static修饰的成员变量，称之为静态成员变量，静态成员变量一定要在类外进行初始化

class Test
{
private:static int _n;
};// 静态成员变量的定义初始化 类外进行初始化
int Test::_n = 0;

static特点

1.静态成员变量为所有类对象所共享，不属于某个具体的对象，不存在对象中，存放在静态区

#include <iostream>
using namespace std;
class Test
{
private:static int _n;
};
int main()
{cout << sizeof(Test) << endl;return 0;
}

计算出该对象的大小为1，说明该类中不含_n,_n是存储在静态区的

2.用static修饰的成员函数，称之为静态成员函数，静态成员函数没有this指针
3.静态成员函数中可以访问其他的静态成员，但是不能访问非静态的，因为没有this指针。含有静态成员变量的类，一般含有一个静态成员函数，用于访问静态成员变量

class Test
{
public:static void Fun(){cout << _a << endl; //错误 不能访问非静态成员cout << _n << endl; // 可以访问静态成员}
private:int _a; //非静态成员static int _n; //静态成员
};

4.非静态的成员函数，可以访问任意的静态成员变量和静态成员函数
5. 突破类域就可以访问静态成员，可以通过类名::静态成员或者对象.静态成员来访问静态成员变量和静态成员函数
6. 静态成员也是类的成员，受public、protected、private访问限定符的限制

注意区分两个问题：
 1、静态成员函数可以调用非静态成员函数吗？
 2、非静态成员函数可以调用静态成员函数吗？
 
问题1： 不可以。静态成员函数中没有this指针，无法访问任何非静态成员，故静态成员函数不可调用非静态成员函数。
问题2： 可以。因为静态成员函数和非静态成员函数都在类中，在类中不受访问限定符的限制。

C++11中成员初始化的新用法

C++11支持非静态成员变量在声明时进行初始化赋值，但是这里不是初始化，而是给声明的成员变量一个缺省值

class A
{
private:// 非静态成员变量，可以在成员声明时给缺省值。int _a = 10; int* _p = (int*)malloc(4);//静态成员变量不能给缺省值static int _n; 
};

初始化列表是成员变量定义初始化的地方，如果有给值，就用你所给的值对成员变量进行初始化，如果没有给值，则用缺省值进行初始化，如果没有缺省值，则内置类型的成员为随机值

友元

友元分为：友元函数和友元类。
友元提供了⼀种突破类访问限定符封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用

友元函数

友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字

例子：

class Date
{// 友元函数的声明 在函数声明前加上关键字friendfriend ostream& operator<<(ostream& out, const Date& d);public:Date(int year = 0, int month = 1, int day = 1){_year = year;_month = month;_day = day;}
private:int _year;int _month;int _day;
};// <<运算符重载  类外部进行定义
ostream& operator<<(ostream& out, const Date& d)
{out << d._year << "-" << d._month << "-" << d._day<< endl;return out;
}

友元函数特点

1.友元函数可访问类的私有和保护成员，友元函数仅仅是⼀种声明，他不是类的成员函数
2.友元函数可以在类定义的任何地⽅声明，不受类访问限定符限制
3.⼀个函数可以是多个类的友元函数
4.友元函数不能用const修饰
5.友元函数的调用与普通函数的调用原理相同

友元类

友元类的所有成员函数都可以是另一个类的友元函数，可以访问另一个类中所有成员

class A
{// 声明B是A的友元类 即将B类作为朋友 B类的所有成员函数都是A类的友元函数// B类的成员函数可以访问A类的所有成员friend class B;
public:A(int n = 0):_n(n){}
private:int _n;
};class B
{
public:void Test(A& a){// B类可以直接访问A类中的私有成员变量cout << a._n << endl;}
};

友元类的特点

1.友元类中的成员函数都可以是另⼀个类的友元函数，都可以访问另⼀个类中的私有和保护成员
2. 友元类的关系是单向的，不具有交换性，⽐如A类是B类的友元，但是B类不是A类的友元
3. 友元类关系不能传递，如果A是B的友元，B是C的友元，但是A不是C的友元

内部类

如果⼀个类定义在另⼀个类的内部，这个内部类就叫做内部类

内部类的特点

1.内部类是⼀个独立的类，内部类不属于外部类，不能通过外部类的对象调用内部类
2.外部类对内部类没有任何优越的访问权限
3.内部类默认是外部类的友元类，但是外部类不是内部类的友元
4.内部类可以直接访问外部类中的static、枚举成员，不需要外部类的对象/类名

#include <iostream>
using namespace std;
class A //外部类
{
public:class B //内部类{private:int _b;};
private:int _a;
};
int main()
{cout << sizeof(A) << endl; //外部类的大小return 0;
}

这里外部类A的大小为4，所以大小与内部类的大小无关