四.static的应用：“求1+2+3+...n的和"
步骤：
- 将成员变为静态成员变量
- 利用访问操作符与静态成员函数GetRet()得到_ret（和）
图示：
五.static应用："实现一个类，计算程序中创建出了多少个类对象"
原理：
- 定义一个静态成员变量_scount，再在类中声明一个访问静态成员变量的静态成员函数GetACount()；
- 构造++_scount，析构--_scount；
代码演示：
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; 静态成员变量类外定义 void TestA() { cout << A::GetACount() << endl; ::来访问静态成员变量 A a1, a2; A a3(a1); cout << A::GetACount() << endl; }
6.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; }
二.相关知识补充：隐式类型转换
类型转换会产生临时变量
PS：构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值的构造函数，还具有类型转换的作用
图示：
1.为什么加上"引用"无法发生隐式类型转换
PS：涉及到权限知识点（可见同博客【三.const.权限知识点】）
图示：
7.友元
引入：友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。 友元分为：友元函数和友元类
通俗而言：友元函数的声明表达了友元函数能够访问这个类的权限，相当于客人（友元）函数拥有主人家的钥匙（友元声明），可以随便进出主人家里，偷吃主人家里的饼干（访问私有域成员） 。但是一个屋子有太多钥匙不太安全，故不要多给钥匙（友元不宜多用）
一.友元函数
友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字
说明：
友元函数可访问类的私有和保护成员，但不是类的成员函数
友元函数不能用const修饰
友元函数可以在类定义的任何地方声明，不受类访问限定符限制
一个函数可以是多个类的友元函数
友元函数的调用与普通函数的调用原理相同
友元函数的声明与函数声明不同，仅仅是表达权限
代码演示：
class Date { //友元函数声明——表达一种权限（函数可以访问类内对象） 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; }; 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类中私有的成员变量则不行。
友元关系不能传递 （如果B是A的友元，C是B的友元，则不能说明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; };
8.内部类
概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。
注意：内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访问外部类中 的所有成员。但是外部类不是内部类的友元。
特性：
内部类可以定义在外部类的public、protected、private都是可以的。
注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
sizeof(外部类)=外部类，和内部类没有任何关系。
9.匿名对象(即临时对象）
特性：
匿名对象的生命周期在当前行
匿名对象具有常性
const+引用 ：会延长匿名对象生命周期，生命周期在当前函数局部域
int main() { A aa(1); // 有名对象 -- 生命周期在当前函数局部域 A(2); // 匿名对象 -- 生命周期在当前行 Solution sl; sl.Sum_Solution(10); Solution().Sum_Solution(20); //A& ra = A(1); // 匿名对象具有常性 const A& ra = A(1); // const引用延长匿名对象的生命周期，生命周期在当前函数局部域 A(10); Solution().Sum_Solution(20); string str("11111"); push_back(str); push_back(string("222222")); push_back("222222"); return 0; }
10.初始化列表
一.初始化列表和构造函数的关系
引入：构造函数调用之后，对象中已经有了一个初始值，但是不能将其称为对对象中成员变量的初始化， 构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。
二.初始化列表基本结构
初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。
代码展示：
class Date { public: Date(int year, int month, int day) 初始化列表 : _year(year) , _month(month) , _day(day) {} private: int _year; int _month; int _day; };
三.初始化列表使用场景
每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
类中包含以下成员，必须放在初始化列表位置进行初始化：
引用成员变量
const成员变量
自定义类型成员(且该类没有默认构造函数时 ）
缺省值与初始化列表的关系： （下列代码中 int x 有演示）
初始化列表没显式定义，缺省值给到初始化列表
初始化列表显式定义，以初始化列表为主
代码展示：
class A { public: 内置类型可以放到初始化列表中初始化 A(int a) :_a(a) {} private: int _a; }; class B { public: B(int a, int ref) 必须放到初始化列表中进行初始化 :_aobj(a) ,_ref(ref) ,_n(10) {} private: A _aobj; // 没有默认构造函数 （无参/全缺省/默认生成） int& _ref; // 引用 const int _n; // const int x = 3； 缺省值为3，缺省值是给初始化列表的 但是如果初始化列表中显式定义，则以初始化列表为主 };
四.尽量使用初始化列表初始化
尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。
五.成员变量在初始化列表中的初始化顺序
成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关
图示：
11.类的六个默认成员函数
当没有显式定义(我们不主动写时)，编译器会自动生成
1.构造函数
默认构造函数(3种)：(1)类自己生成的函数（2）无参 （3）全缺省的函数
特征： (不传参就可以调用）
构造函数的主要任务是初始化对象，如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义，编译器将不再生成。
运作上看，当对象实例化时，编译器会自动调用它
形态上看，其名字与类名相同，且无返回值
注意点，构造函数允许重载
一.什么时候需要自己写构造函数？
需要自己写的情况：
一般情况下，有内置类型成员，要自己写（否则会初始化成随机值）
不需要自己写的情况：
当内置类型成员都有缺省值时，且初始化符合要求，可以考虑让编译器自己生成
全部都是自定义类型成员(例如:Stack)，可以考虑让编译器自己生成
注意！！！
二.构造函数可以使用重载和不可以使用重载的情况
构造函数可以用重载的情况：
typedef int DataType; class Stack { public: Stack(DataType* a, int n) //特定初始化 { cout << "Stack(DataType* a, int n)" << endl; _array = (DataType*)malloc(sizeof(DataType) * n); if (NULL == _array) { perror("malloc申请空间失败!!!"); return; } memcpy(_array, a, sizeof(DataType) * n); _capacity = n; _size = n; } //调用时可用以用d1，使用上方的构造函数 Stack d1(int, 11); //Stack d1(); // 不可以这样写，会跟函数声明有点冲突，编译器不好识别 Stack d2; //调用时可以用d2，使用下方的构造函数 Stack(int capacity = 4) //构造函数(全缺省） { cout << "Stack(int capacity = 4)" << endl; _array = (DataType*)malloc(sizeof(DataType) * capacity); if (NULL == _array) { perror("malloc申请空间失败!!!"); return; } _capacity = capacity; _size = 0; } /*以下代码仅为完整性 void Push(DataType data) { CheckCapacity(); _array[_size] = data; _size++; } void Pop() { if (Empty()) return; _size--; } DataType Top() { return _array[_size - 1]; } int Empty() { return 0 == _size; } int Size() { return _size; } ~Stack() { cout << "~Stack()" << endl; if (_array) { free(_array); _array = NULL; _capacity = 0; _size = 0; } } private: void CheckCapacity() { if (_size == _capacity) { int newcapacity = _capacity * 2; DataType* temp = (DataType*)realloc(_array, newcapacity * sizeof(DataType)); if (temp == NULL) { perror("realloc申请空间失败!!!"); return; } _array = temp; _capacity = newcapacity; } }*/ private: DataType* _array; int _capacity; int _size; };
构造函数不能用重载的情况：无参调用存在歧义
// 构成函数重载 // 但是无参调用存在歧义 Date() { _year = 1; _month = 1; _day = 1; } Date(int year = 1, int month = 1, int day = 1) { _year = year; _month = month; _day = day; }
12.析构函数
析构函数的主要任务是清理对象
运作上看，当对象生命周期结束时，编译器会自动调用它
形态上看，其在类名前加上~，且无返回值
注意点，析构函数不允许重载。
默认析构函数：与默认构造函数类似，编译器对内置类型成员不做处理，对自定义类型会去调用它的析构函数。
一.什么时候需要自己写析构函数？
需要自己写的情况：
有动态申请资源时，需要自己写析构函数释放空间。(防止内存泄漏）
不需要自己写的情况：
没有动态申请资源时，不需要自己写，系统会自动回收空间。
需要释放资源的对象都是自定义类型时，不需要自己写。
3.拷贝构造函数
行为：在创建对象时，创建一个与已存在对象一模一样的新对象
拷贝构造函数：
只有单个形参，该形参是对本类类型对象的引用（一般常用const修饰）
在用已存在的类类型对象创建新对象时由编译器自动调用（区分于构造函数）
拷贝构造函数是构造函数的一个重载形式
已知类Date，已经有实例化的对象 Date d1； 此时想得到一个和d1一模一样的对象d2； Date d2(d1); 类中若有拷贝构造Date (const Date d); 直接进行调用; d2传给没有显示的this指针，d1传给const Date d; Date d2(const Date d1)
- 拷贝构造函数的参数只有一个且必须是类类型对象的引用
当拷贝构造函数为 Date(const Date &d);//引用 Date(const Date d);//错误写法 Date(const Date &d) { this->_year = d.year; this->_month =d.month; this->_day =d.day; } //this 为d2的指针，d为拷贝的类d1
- 原因：【使用传值方式编译器直接报错，因为会引发无穷递归调用】（错误方式）
一.什么时候需要自己写拷贝构造函数？
默认生成的拷贝构造函数为：浅拷贝
需要自己写的情况：
- 自定义类型必须使用拷贝构造（深拷贝）
不需要自己写的情况
- 内置类型直接拷贝（浅拷贝/值拷贝）
例：Date类中都是内置类型，默认生成的拷贝构造函数为浅拷贝可以直接用；
而Stack类为自定义类型，其中有a指针指向一块新开辟的空间。此时需要自己写拷贝构造函数。
二.默认拷贝构造（浅拷贝）的缺陷：
浅拷贝的缺陷：(默认拷贝构造运用引用防止死递归的后遗症）
4.运算符重载函数
运算符重载：
- 参数类型：const T& （传递引用可以提高传参效率）
- 函数名：关键字operator后面接需要重载的运算符符号
- 函数原型：返回值类型+operator操作符+(参数列表）
例：转化演示
注意：
不能通过连接其他符号来创建新的操作符：例如operator@
重载操作符必须有一个类类型参数
用于内置类型的运算符，其含义不能改变：例如+
作为类成员函数重载时，其形参看起来比操作数少一个（因为成员函数的第一个参数为隐藏的this）
.* / :: /sizeof/ ?: /./这五个运算符不能重载
一.运算符重载函数和构造函数使用区别：
5.赋值重载函数
赋值运算符重载格式：
参数类型：const T& （传递引用可以提高传参效率）
返回值类型：T& （返回引用可以提高返回的效率，有返回值的目的是为了支持连续赋值）
检测是否可以自己给自己赋值
返回*this：（对this指针解引用，要符合连续赋值的含义）
赋值运算符只能重载成为类的成员函数而不能重载成全局函数（如果重载成全局函数，编译器会生成一个默认运算符重载）
用户没有显示实现时，编译器会生成一个默认赋值运算符重载，以值的方式(浅拷贝）逐字节拷贝。（注意点：内置类型成员变量直接赋值，只有自定义成员变量需要调用对应的赋值运算符重载）
6.取地址与取地址重载
引入： 内置类型取地址时有取地址操作符，而自定义类型呢？于是出现了取地址重载。它用到的场景非常少，可以说取地址重载——补充这个语言的完整性，更加系统。
这两个默认成员函数一般不用重新定义 ，编译器默认会生成
这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比如不想让别人获取到指定的内容！ （设为nullptr）
代码演示：
class Date { public : Date* operator&() { return this ; // return nullptr;让普通成员的this指针不被取到 } const Date* operator&()const { return this ; } private : int _year ; // 年 int _month ; // 月 int _day ; // 日 };
