前言 ：新关键字explicit 的引入
临时变量具有常属性（ 不可修改，要加const ）。
内置类型 整形和浮点形（意义非常相近，表示数字大小） 隐式互相转换
int和指针 只能显式转【强制类型转换】
内置类型 —隐式转换—> 自定义类型 ：【 类型转换都是通过 临时变量 做中间值，由 构造函数来支持 】
能支持这个转换，就看 类里面有没有 相对应类型 的单参数/ 支持传一个参数/多参数带缺省（也可以）的半缺省（ 这些都看实际具体的情况是否有同对应类型的参数条件 ）构造函数支持转换。
若不想让隐式类型转换发生，C++引入入新关键字explicit。
一、explicit关键字
不想让隐式类型转换发生，构造函数加explicit【 但若要显式转换（强制类型）也防不住的 】
【 虽然大部分在传值时都有隐式类型转换，可以大大方便我们很多，但有些地方并不想让其自动调用隐式类型转换（如后面会学到的 智能指针） 】
- 多参数：
- d2
,逗号表达式：有返回值的，且返回值取的是最后那一个 。
- d3 多参数带缺省
- d4
{ }隐式类型转换 【支持多参数】
【（调试）走了构造函数，中间也生成了临时变量 。】
C++98不支持，C++11支持
构造函数 不仅可以 构造与初始化对象，对于单个参数或者除第一个参数无默认值，其余均有默认值的构造函数，还具有 类型转换 的作用。
- 单参构造函数，没有使用explicit修饰，具有类型转换作用
explicit修饰构造函数，禁止类型转换 — explicit去掉之后，代码可以通过编译 - 虽然有多个参数，但是创建对象时后两个参数可以不传递，没有使用explicit修饰，具有类型转换作用
explicit修饰构造函数，禁止类型转换
class Date { public: // 1. 单参构造函数，没有使用explicit修饰，具有类型转换作用 // explicit修饰构造函数，禁止类型转换---explicit去掉之后，代码可以通过编译 explicit Date(int year) :_year(year) {} /* // 2. 虽然有多个参数，但是创建对象时后两个参数可以不传递，没有使用explicit修饰，具有类型转换作用 // explicit修饰构造函数，禁止类型转换 explicit 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; }; void Test() { Date d1(2022); // 用一个整形变量给日期类型对象赋值 // 实际编译器背后会用2023构造一个无名对象，最后用无名对象给d1对象进行赋值 d1 = 2023; // 将1屏蔽掉，2放开时则编译失败，因为explicit修饰构造函数，禁止了单参构造函数类型转换的作用 }
二、static成员
（一）概念
声明为 static的类成员 称为 类的静态成员，用static修饰的成员变量，称之为 静态成员变量；用 static修饰的成员函数 ，称之为 静态成员函数。静态成员变量一定要在类外进行初始化
【 面试题 】实现一个类，计算程序中创建出了多少个类对象。
class A { public: A() { ++_scount; } A(const A& t) { ++_scount; } ~A() { --_scount; } static int GetACount() { return _scount; } private: //声明 static int _scount; }; 【 声明和定义必须分离 】 //定义 _ 在类外面定义，可以认为它是一个全局变量，只不过是放到类里面去了，归类私有 int A::_scount = 0; //初始化在main函数之前 void TestA() { cout << A::GetACount() << endl; A a1, a2; A a3(a1); cout << A::GetACount() << endl; }
★【 声明和定义必须分离 】
定义 —— 在类外面定义，可以认为它是一个全局变量，只不过是放到类里面去了，归类私有
（二）特性
- 静态成员为【 属于整个类 】所有类对象所共享，不属于某个具体的对象，存放在静态区
- 静态成员变量
aa.count => 去类里面找count
- 静态成员变量必须在类外定义，定义时不添加static关键字，类中 只是声明
- 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问
- 静态成员函数没有隐藏的this指针【没有对象调用（ 直接去类里去找【指定类域就行了】，所以不需要this指针 ）】，不能访问任何非静态成员
- 静态成员 也是类的成员，受 public、protected、private 访问限定符的限制
提供 Get（），只读不写【 能读 但修改不了 】
要是没有创建对象 A aa，还怎么调用类里面的Get（）？
- 为了调用创建一个 有名对象
类 对象名，再通过这个对象，进入到类中访问GetCount（）
A aa； aa.GetCount () -1 ;
三、匿名对象
- 匿名对象
类（），匿名对象，生命周期只在这一行 。
A aa 有名对象 ；A() 匿名对象 。
【有名对象要写两行，A() 匿名对象一行就可以，且生命周期就在这一行 】
- 总结：
静态成员变量和静态成员函数，本质就是受限制的全局变量和全局函数。
专属这个类，受类域和访问限定符的限制【封装】
size=4（ 只算入了int _a=0; 的大小，而没有算入 static int count 的大小 ）
【 static修饰的（还是全局的，本质就只是专属于类域里面了） 不存在对象里 ，所以是4个字节 】
和静态一样
static 就是一个全局类
编译器在编译时，检查语法
- 只会向上找【提高编译的速度】
- 只会在全局去找
普通成员函数：1. 要在类里面找到其出处 2. 隐藏的this指针
【问题】
**1. 静态成员函数可以调用非静态成员函数吗？
- 非静态成员函数可以调用类的静态成员函数吗？**
四、友元
前言：友元的引入
友元提供了一种 突破封装 的方式，有时提供了便利。【 虽然封装很好用，但有些地方就需要突破一下封装 】但是友元会增加耦合度，破坏了封装，所以友元不宜多用。
（一）友元的概念
友元是一种 在类外面 去突破封装 访问私有保护
友元分为：友元函数 和 友元类
（二）友元函数
前言：友元函数引入
友元函数：全局函数想访问私有的变量 【只能解决全局函数的问题，无法解决全局变量想访问私有的变量的问题 => 还是得用static】
问题：现在尝试去重载operator<<，然后发现没办法将operator<<重载成成员函数。因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。
但是实际使用中cout需要是第一个形参对象，才能正常使用。所以要将operator<<重载成全局函数。但又会导致类外没办法访问私有成员，此时就需要友元来解决。operator>>同理。
class Date { public: Date(int year, int month, int day) : _year(year) , _month(month) , _day(day) {} ★ // 在类中，成员函数第一个参数一定是 隐藏的this，所以 d1必须放在<<的左侧 ★ // 实际 d1.operator<<(&d1, cout) -> d1 << cout;【控制台反了， 不符合可读性】 //在类中以成员函数来实现 ostream& operator<<(ostream& _cout) { _cout << _year << "-" << _month << "-" << _day << endl; return _cout; } private: int _year; int _month; int _day; };
（1）友元函数的语法
- 友元函数 可以 直接访问 类的私有成员
- 它是 定义在类外部 的 普通函数 ，不属于任何类
- 但 需要在类的内部声明，声明时需要加friend关键字。
重点说明：
- 友元函数可访问类的私有和保护成员，但不是类的成员函数
【 友元函数在类里面定义（可访问类的私有和保护成员），但它不是成员函数【成员函数一个特征 有隐藏的this指针 】 】 - 友元函数 不能用const修饰
- 友元函数可以在类定义的任何地方声明，不受类访问限定符限制
- 一个函数可以是 多个类的友元函数
- 友元函数的调用 与 普通函数的调用 原理相同
class Date { //需要在类的内部声明 //声明时需要加friend关键字。 //可以在类定义的任何地方声明，不受类访问限定符限制 friend ostream& operator<<(ostream& _cout, const Date& d); friend istream& operator>>(istream& _cin, Date& d); public: Date(int year = 1900, int month = 1, int day = 1) : _year(year) , _month(month) , _day(day) {} private: int _year; int _month; int _day; }; //定义在类外部 //的普通函数，不属于任何类 //放类外不是类成员函数，就没有隐藏的this指针了，就不用第一个参数放d了 ostream& operator<<(ostream& _cout, const Date& d) { _cout << d._year << "-" << d._month << "-" << d._day; return _cout; } istream& operator>>(istream& _cin, Date& d) { _cin >> d._year; _cin >> d._month; _cin >> d._day; return _cin; } int main() { Date d; cin >> d; cout << d << endl; return 0; }
（三）友元类
友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。
- 友元关系是单向的，不具有交换性。
比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接
访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。 - 友元关系不能传递
如果C是B的友元， B是A的友元，则不能说明C时A的友元。 - 友元关系 不能继承，在继承位置再给大家详细介绍。
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; };
（四）内部类
概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。 内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。
注意：内部类天生就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。
但是外部类不是内部类的友元。
特性：
- 内部类可以定义在 外部类的public、protected、private 都是可以的。
- 注意 内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名 。
- sizeof(外部类)=外部类，和内部类没有任何关系。
【内部域与外部域 的对比】
五、拷贝对象时的一些编译器优化
在传参和传返回值的过程中，一般编译器会做一些优化，减少对象的拷贝，这个在一些场景下还是非常有用的。
- 情况一：拷贝构造 + 拷贝构造 ——> 拷贝构造
本来是有两次拷贝构造的，
编译器优化成只调用一次拷贝构造
- 情况二
A（2）匿名函数 直接构造 + 拷贝构造 ——> 构造
- 情况三 拷贝构造+拷贝构造 —> 直接优化成一次拷贝构造
连续的拷贝构造，会被编译器直接优化成一次拷贝构造
- 连续的表达式中， 拷贝构造和赋值构造，编译器不会进行优化
练习题
- .求1+2+3+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句 OJ链接
题目分析：
不能使用乘除法（ no 等差数列公式 ）、for、while（ no 循环 ）、if、else、switch、case等关键字及条件判断语句（A?B:C）。no 位运算。no 递归。
思路步骤：
（1） （OJ题里能）开辟变长数组，每开辟一块 arr [ i ] 调用一次类构造函数进行初始化 [ _ret += _i ; ++ _i ; ] 要累积，所以要 static 修饰变量，【类里声明，类外定义（虽是类外，但也是通过域限定符访问其中）】。
（2）由于private权限，并不能直接访问 _ret 要通过 GetRet()
（3）
对象 . 取成员
类::(类域)
