一、初始化列表
先看下面这段代码
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 _N; }; int main() { Date d1(2022, 1, 19);//对象定义/对象实例化 return 0; }
以日期类为例：类被定义出来以后，对于成员变量它是一种声明，告诉我们变量的类型与名称，并非初始化；
当在主函数中对类进行实例化时，类就被初始化了，类里面包含的成员变量也就被定义了，这里要注意构造函数里的语句只是对成员变量进行赋值，并非初始化；
我们可以看到在成员变量中有一个 const int _N;的成员变量，对于这种加了const的变量，只有在定义的同时进行初始化；
为了解决这样的问题，C++就有了一个初始化列表，来确保以上的变量能够在定义的时候就初始化了；
1.初始化列表的使用方法
初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。
class Date { public: //初始化列表 - 成员变量定义的地方 Date(int year, int month, int day, int i) :_N(10) ,_year(year) ,_month(month) ,_day(day) {} private: int _year; int _month; int _day; const int _N; //const };
注意：
1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
2. 类中包含以下成员，必须放在初始化列表位置进行初始化：
引用成员变量
const成员变量
自定义类型成员(该类没有默认构造函数)
class A { public: A(int a )//如果这里没有显示定义A（int a） { _a = a; } private: int _a; }; class Date { public: //初始化列表 - 成员变量定义的地方 Date(int year, int month, int day, int i) : _N(10) , _ref(i) , _aa(-1) , _year(year) , _month(month) , _day(day) {} private: int _year; int _month; int _day; /*以下几种必须在定义的时候初始化*/ const int _N; //const int& _ref; //引用 A _aa; //没有默认构造函数的成员变量 }; int main() { int i = 0; Date d1(2022, 1, 19, i); return 0; }
2.初始化列表的优势
使用和不使用初始化列表区别在哪呢？通过下面的代码的运行结果，来进行总结：
class A { public: A(int a = 0)//如果这里没有显示定义A（int a） { cout << "int a = 0" << endl; _a = a; } A(const A& aa) { cout << "const A& aa" << endl; _a = aa._a; } A& operator=(const A& aa) { cout << "operator=(const A& aa)" << endl; _a = aa._a; return *this; } private: int _a; }; class Date { public: //不使用初始化列表 Date(int year, int month, int day,const A& aa) { //进入函数体内时，成员变量已经定义出来了 _aa = aa; _year = year; _month = month; _day = day; } //使用初始化列表 //Date(int year, int month, int day, const A& aa) // :_aa(aa) //{ // //进入函数体内时，成员变量已经定义出来了 // _year = year; // _month = month; // _day = day; //} private: int _year; int _month; int _day; A _aa; }; int main() { A aa(10); Date d1(2022, 1, 18, aa); return 0; }
所以，使用初始化列表能在一定程度上提高效率，因此也是得到了广泛的应用；
注意：
成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关；也就是说你编写的初始化列表不是按照成员变量的声明顺序进行初始化，但是程序运行时是按照成员变量的声明顺序进行初始化的；
例如：判断下面的代码的运行结果？
class A { public: A(int a) :_a1(a) , _a2(_a1) {} void Print() { cout << _a1 << " " << _a2 << endl; } private: int _a2; int _a1; }; int main() { A aa(1); aa.Print(); }
首先，成员变量的声明顺序是 _a2 、_a1 ，但是初始化列表的顺序是 _a1 、_a2；按照我们刚才所讲的，编译器会先初始化 _a2，再初始化 _a1；所以_a2就是随机值，_a1 是1；
3.explicit关键字
构造函数不仅可以构造与初始化对象，对于单个参数的构造函数，还具有类型转换的作用；
class Date { public: Date(int year) :_year(year) {} //如果不想让Date d1 = 2022;转换发生 需要加上explicit关键字 explicit Date(int year) :_year(year) {} private: int _year; }; int main() { Date d1(2022); d1 = 2023; //用2023构造一个临时对象Date(2023)，再用这个对象拷贝构造d2 return 0; }
上述代码可读性不是很好，用explicit修饰构造函数，将会禁止单参构造函数的隐式转换；
二、static成员
1.定义
声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态的成员变量一定要在类外进行初始化；
class A { public: A(int a = 0) :_a(a) { ++_scount; } A(const A& aa) :_a(aa._a) { ++_scount; } //没有this指针，只能访问静态的成员变量和成员函数 static int GetCount() { return _scount; } private: int _a; //静态成员变量属于整个类，所有对象，生命周期在整个程序运行器件 //类的成员函数中可以随便访问 static int _scount;//声明 }; int A::_scount = 0;//在类外定义初始化 int main() { A a1; A a2 = 1; //类外面访问---建立在public //cout << A::_scount << endl; //cout << a1._scount << endl; //cout << a2._scount << endl; cout << A::GetCount() << endl; cout << a1.GetCount() << endl; return 0; }
2.特性
1. 静态成员为所有类对象所共享，不属于某个具体的实例
2. 静态成员变量必须在类外定义，定义时不添加static关键字
3. 类静态成员即可用类名 :: 静态成员或者对象 . 静态成员来访问
4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
5. 静态成员和类的普通成员一样，也有public、protected、private3种访问级别，也可以具有返回值
3.计算1+2+3+...+n的值
class Solution { private: class Sum { public: Sum() { _ret += _i; ++_i; } static int GetRet() { return _ret; } private: /*静态变量的声明*/ static int _i; static int _ret; }; public: int Sum_Solution(int n) { Sum a[n];//创建了n个对象的数组 return Sum::GetRet();//访问静态变量 _ret } }; /*静态变量的定义*/ int Sum::_i = 1; int Sum::_ret = 0;
