1. 构造函数与初始化列表

1.1 对象的创建与构造函数的初始化

1. 在前面的学习中，我们尝试了对简单类（日期类）进行了实现，而后在使用中我们通过定义类模板然后实例化的方式，创建我们所需要的对象。
2. 在这一过程中，编译器按照所指定的类型去相应的内存区域中申请空间，在已经创建好变量后，再调用构造函数对生成的对象进行初始化。
3. 大多数情况下，这种初始化的方式都不会出现问题，可是当类的成员变量中有一些特定的类型比如，const修饰的变量，引用类型的变量，没有默认构造函数的自定义类型，此时，这种初始化方式就行不通了。（默认构造函数：编译器自动生成，无参数，有缺省参数）

1.2 初始化列表及构造函数存在的意义

1. 内置类型可以在创建变量申请空间时就进行变量的初始化，而自定义类型是否也可以在创建变量的同时就进行初始化，它的初始化方式是什么，接下来，我们引出类与对象中的初始化列表。
2. 类实例化生成对象时并不是只开辟空间，对空间中的内容不做处理，而是会调用初始化列表对开辟出的空间进行初始化。前面之所以无法对特殊类型无法进行初始化，是因为我们没有向初始化列表中添加内容。

3. 初始化列表的定义方式：

//构造函数
class A
{
private:int _a;int _b;int _c//构造函数，函数体之前，语法如下：A(int a, int b ,int c):_a(a),_b(b),_c(c){}
}

4. 初始化列表的调用方式：（三种必须用初始化列表进行初始化的成员变量）

//没有缺省参数
class A
{
public:A(int d){_d = d;}int _d;
};class B
{
public:const int _a;int& _b;A _c;//构造函数B(int b, int c):_a(10),_b(b),_c(c){cout << " _a = " << _a << " _b = " << _b << " _c._d = " << _c._d << endl;}
};int main()
{int b = 20;int c = 30;B a(b, c);return 0
}

5. 初始化列表初始化成员变量的顺序：
   初始化列表进行初始化的顺序是根据成员变量的声明顺序决定的

class A
{
public:int _b;int _a;//先初始化_a，再初始化_bA(int a = 0):_a(a),_b(_a){}void Print(){cout << _a << ' ' << _b << ' ' << endl;}
};int main()
{A a(10);a.Print();return 0;
}

执行结果：使用成员变量_a初始化成员变量_b时，_a还没有被初始化

6. <1> 既然初始化列表可以进行初始化，并且初始化列表能做到构造函数无法做到的特殊类型成员的声明，那么，为什么还要有构造函数呢？
   <2> 初始化列表能做的只有初始化，无法对初始化后的变量做检查与合法性判断

class A
{
public:int* _a;A(int n):_a((int*)malloc(n * sizeof(int))){if (_a == nullptr){perror("malloc failed");exit(-1);}}
};

1.3 explicit关键字与构造函数的类型转换

1. 类的默认成员函数operator=重载，其构造函数在只有单参数或拥有缺省参数，支持用与成员变量类型相同的数据，变量直接进行赋值操作。

class Date
{
public:int _year;int _month;int _day;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;}
};int main()
{Date d1(2024);d1 = 2025;int year = 2026;d1 = year;cout << d1._year << '-' << d1._month << '-' << d1._day << endl;return 0;
}

支持上述操作的原因，是因为数据或者变量会进行类型转换构造临时对象，然后再用临时构造出的对象进行赋值操作。

2. explicit关键字，修饰构造函数，使得这个构造函数所在的类其，实例化的对象不会发生类型转换的操作。

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

2. static成员变量与static成员函数

2.1 static成员变量

1. 静态成员变量也是类的成员之一，它不独属于某个对象，而是属于这个类，为所有实例化对象所共有，存放在静态区。
2. 静态成员变量在类中声明，在类外定义，在类外定义时不需要加static关键字。
3. 静态成员变量的调用方式为，对象.静态成员变量，类区域::静态成员变量
4. 静态成员变量也受访问限定符的限制

class A
{
public:static int _count;A(){++_count;}A(const A& a){++_count;}~A(){--_count;}
};int A::_count = 0;int main()
{A a1;cout << a1._count << endl;a1.~A();cout << A::_count << endl;return 0;
}

2.2 static成员函数

1. 与静态成员变量类似，静态成员函数也是属于全体实例化对象，而不是属于某个对象。
2. 静态成员函数的定义方式，也是类内声明类外定义。
3. 静态成员函数没有this指针，不能调用非静态成员变量。
4. 静态成员函数的调用方式，对象.静态成员函数，类域::静态成员函数
5. 同样的静态成员函数也受访问限定符限制。

class A
{
//public:static int _count;static int GetCount();
public://非静态成员函数可以调用静态成员函数void Print(){cout << (*this).GetCount() << endl;cout << "hello" << endl;}A(){++_count;}A(const A& a){++_count;}~A(){--_count;}
};int A::_count = 0;
int A::GetCount()
{//静态成员函数没有this指针//无法调用非静态成员函数return A::_count;
}

3. 日期类流插入操作符的重载与友元

1. 当我们尝试对实现过的日期类进行流插入运算的重载时，当把它作为成员函数时，我们发现无法实现。
2. 操作数的次序为操作符重载函数的参数从左往右，分别是操作符的第一个，第二个…操作数。
3. 成员函数的一个参数都为隐藏的默认参数this指针，而流插入操作符的需要的第一个参数是ostream类型的变量。可是，当我们不使用成员函数的方式实现，那么函数就无法访问private访问限定符修饰的成员变量。

4. 那么，流插入操作符的重载就无法实现吗，这里我们引入C++新的内容，友元。

3.1 友元

1. 友元关系的实际应用分为友元类与友元函数，这是一种突破类访问限定符封装的方式，它在提供了这种功能的同时，也不可避免地增加了代码的耦合性，不建议多用。

3.2 友元函数

1. 友元函数是普通函数，它定义在类外。而它达成友元的方式为，在类中对其进行友元声明。
2. 友元函数可以在类中的任何地方声明，不受访问限定符影响。
3. 友元函数的声明方式为，在普通的函数声明前加关键字friend。
4. 一个函数可以是多个类的友元函数。

class Date
{
public:int _year;int _month;int _day;Date(int year, int month = 1, int day = 1):_year(year),_month(month),_day(day){}friend ostream& operator<<(ostream& out, const Date& d);friend istream& operator>>(istream& out, const Date& d);
};ostream& operator<<(ostream& out, const Date& d)
{out << d._year << '-' << d._month << '-' << d._day;return out;
}istream& operator>>(istream& in, Date& d)
{in >> d._year >> d._month >> d._day;return in;
}

3.3 友元类

1. 友元类的所有成员函数都是另一个类的友元函数，可以访问另一个类的所有私有成员。
2. 友元类关系是单向的。
3. 友元关系不可传递，A类是B类友元，B类是C类的友元，A类不是C类的友元，不可以访问C类。
4. 友元关系不能被继承
5. 友元类的声明方式为，在需要被访问的类中声明其的友元类，friend + 类名。

class Time
{
public:Time(int hour = 0, int minute = 0, int seconds = 0):_hour(hour), _minute(minute), _seconds(seconds){}friend class Date;private:int _hour;int _minute;int _seconds;
};class Date
{
public:int _year;int _month;int _day;Time _t;Date(int year, int month = 1, int day = 1):_year(year),_month(month),_day(day){}void SetTime(){_t._hour = 21;_t._minute = 25;_t._seconds = 0;cout << _t._hour << '/' << _t._minute << '/' << _t._seconds << endl;}
};

4. 内部类

1. 如果一个类定义在另一个类的内部，这个内部类就叫做内部类。
2. 外部类对内部类没有访问权限。
3. 内部类只是在外部类中声明，外部类计算大小时不包含内部。（sizeof(外部类)单纯只是外部类的大小）
4. 内部类对外部类天生就是友元，并且可以直接访问外部类的静态成员变量与函数，无需指定类域。
5. 内部类可以在任意访问限定符的区域声明，在private中时，无法进行内部类的调用实例化对象。

class A
{
private:int _a;static int _c;public:class B{public:void test(A& x){x._a = 10;_c = 20;cout << x._a << endl;cout << x._c << endl;}};
};int A::_c = 0;int main()
{A x;//內部类对象的声明A::B h;h.test(x);return 0;
}

5. 匿名对象

1. 在实例化对象时，省略对象名的创建方式。
2. 匿名对象的声明周期只有一行，紧接着下一行时，就会调用析构函数将其销毁。

class A
{
private:int _ a;
public:A(int a = 0){cout << _a << endl;}void Print(){cout << "hello world" << endl;	}
};//不支持此种调用构造函数的方式，因为无法识别其为函数的声明还是析构函数的调用
A a1();//创建匿名对象的方式
A();//匿名对象调用成员函数
A().Print();

6. 拷贝对象时编译器可能会进行的一些优化

1. 在成员函数传参和传返回值的过程中，一般编译器会做一些优化，减少不必要对象的拷贝
2. 在同一行中，连续的构造，拷贝构造操作编译器会进行优化：（同一表达式中）
   <1> 构造 + 拷贝构造 优化为 构造
   <2> 构造 + 构造 优化为 构造
   <3> 连续的拷贝构造 优化为 直接进行拷贝构造
   （临时对象，匿名对象生命周期只有一行）

class C
{
private:int _c;
public:C(int c){cout << "C()" << endl;}C(const C& tmp){cout << "C(const C&)" << endl;}
};void f1(C aa)
{}C f2()
{C aa;return aa;
}int main()
{//构造 + 拷贝构造，类型转换，生成临时对象C c1(2);//构造 + 拷贝构造 => 构造f1(C(2));//连续的拷贝构造 =>直接进行拷贝构造C c3 = f2();//不会优化，需要引用中间变量const C& c4 = 2;//不会优化，没有在同一表达式中C c5(2);f1(c5);return 0;
}

补充练习：（内部类，访问限定符）

1. 求n!
2. 思路：创建对应数量的对象，在构造函数中++静态成员变量，使用静态成员变量计数

class Solution 
{
private:static int _ret;static int _i;//将内部类定义在private下可保证不被非法访问class B{//默认为私有public:B(){_i++;_ret += _i;}};public:int Sum_Solution(int n) {//将类B设为公有，即可在外部类访问B arr[n];return  _ret;}};int Solution::_i = 0;
int Solution::_ret = 0;