一.再探构造函数之初始化列表• 之前实现构造函数时初始化成员变量都是在函数体内赋值构造函数初始化还有一种方式初始化列表。初始化列表的使用方式是在函数定义处的参数列表后在声明和定义分离时就在真正定义的地方写以一个冒号开始接着是一个以逗号分隔的数据成员列表每个“成员变量”后面都跟一个放在括号中的初始值或表达式class Date { public: Date(int x, int year, int month, int day) :_year(year), _month(month), _day(day) { } private: int _year; int _month; int _day; };• 每一个成员变量在初始化列表中只能出现一次,语法理解上初始化列表可以认为是每个成员变量①定义和②初始化的地方而我们写的函数的函数体内是定义、初始化完毕后进行赋值的地方。• ①引用成员变量②const成员变量③没有默认构造的类类型变量这三种必须放在初始化列表位置其定义的地方进行初始化否则会编译报错。#includeiostream using namespace std; class Time { public: Time(int hour) :_hour(hour) { cout 调用Time()函数 endl; } private: int _hour; }; class Date { public: Date(int x, int year, int month, int day) :_year(year), _month(month), _day(day), _t(12), _rx(x), _n(1) { } private: int _year; int _month; int _day; Time _t; //没有默认构造的类类型变量 int _rx; //引用成员变量 const int _n; //const成员变量 };其本质原因在于①引用成员变量语法要求引用变量必须在定义后立即给一个对象完成初始化且后续不能改变其引用对象。②const成员函数其在于后续的不可更改性无法在函数体内完成赋值操作于是乎必须在初始化的时候就把想要给的值给他。③没有默认构造的类类型变量在进入构造函数体之前编译器会尝试自动调用其默认构造函数。因其没有默认构造编译器就会报错。必须通过初始化列表显式传参调用其指定的带参构造函数。• C11支持在成员变量声明的位置给缺省值这个缺省值主要是给没有显式在初始化列表初始化的成员使用的意思是如果你没有显式的在初始化列表里给这个变量值的化编译器会用这个变量的缺省值在初始化列表初始化。class Time { friend class Date; public: Time(int hour) :_hour(hour) { cout 调用Time()函数 endl; } private: int _hour; }; class Date { public: Date() :_month(2) { cout Date() endl; } void Print() const { cout _year - _month - _day endl; cout _t._hour _n _ptr endl; } private: // 注意这里不是初始化这里给的是缺省值这个缺省值是给初始化列表的 // 如果初始化列表没有显示初始化默认就会用这个缺省值初始化 int _year 1; int _month 1; int _day; Time _t 1;//内置类型也能给缺省值若有多个参数就写成Time t1{10,4} const int _n 1; int* _ptr (int*)malloc(12); }; int main() { Date d1; d1.Print(); return 0; }在这里我们可以试验出_month是根据在初始化列表里显式传的值初始化的而其他变量是在初始化列表用缺省值初始化的。• 初始化列表会按照成员变量在类中的声明顺序进行初始化跟成员在初始化列表中出现的先后顺序无关。为了避免一些奇奇怪怪的错误建议初始化列表顺序和声明顺序保持一致。• 尽量使用初始化列表初始化因为那些你不在初始化列表初始化的成员也会走初始化列表去初始化①如果这个成员在声明位置给了缺省值初始化列表会用这个缺省值初始化。②如果你没有给缺省值对于没有显示在初始化列表初始化的内置类型成员是否初始化取决于编译器C并没有规定。③对于没有显示在初始化列表初始化的自定义类型成员会调用这个成员类型的默认构造函数如果没有默认构造会编译错误。但是函数体的用处也是不可替代的毕竟一些语句如判断判空等也只能写在函数体。综上对初始化列表的语法总结无论是否显示写初始化列表每个构造函数都有初始化列表无论是否在初始化列表显示初始化成员变量每个成员变量都要走初始化列表初始化对初始化列表的使用总结推荐使用初始化列表初始化成员变量1.可以显式在初始化列表初始化2.建议声明时给缺省值若未显式初始化初始化列表也会用这个值初始化该成员二.类型转换• C支持内置类型隐式转换成类类型对象但需要有以该内置类型为参数的构造函数。#includeiostream using namespace std; class A { public: //①号单参数构造 A(int a1) :_a1(a1) { } //②号多参数构造 A(int a1, int a2) :_a1(a1), _a2(a2) { } void Printf() { cout _a1 _a2 endl; } private: int _a1 1; int _a2 2; }; int main() { //隐式类型转换2先用①号构造转换成A类型的对象然后再拷贝构造aa1对象 A aa1 1; aa1 2; aa1.Printf(); //在这里aa2引用了3所转化的临时变量正常的临时变量其声明周期只有一行但是因为我对其引用所以其生命周期就跟着aa2走了 const A aa2 3; //C11之后支持了多参数转换,通过②号构造函数转换来的 A aa3 { 3,4 }; aa3 { 1,6 }; aa3.Printf(); return 0; }• 类类型的对象之间也可以隐式转换和内置类型转类类型一样需要有对应参数的构造函数支撑class A { public: A(int a1, int a2) :_a1(a1), _a2(a2) { } void Printf() { cout _a1 _a2 endl; } int add()const { return _a1 _a2; } private: int _a1 1; int _a2 2; }; class B { public: B(const A a) :_b(a.add()) { } void Printf() { cout _b endl; } private: int _b 0; }; int main() { A aa1 { 2,1 }; //隐式类型转换 B b aa1; aa1.Printf(); b.Printf(); return 0; }• 在构造函数的前面加上explicit就不再支持隐式类型转换class A { public: explicit A(int a) :_a(a) { } private: int _a 0; }; int main() { //编译报错不存在从int转换到A的适当构造函数 //A aa1 2; A aa1(2);//而正常构造没问题 return 0; }三.static成员变量和函数• 用static修饰的成员变量称之为静态成员变量静态成员变量为所有类对象所共享不属于某个具体的对象其也不存在于对象中而是存放在静态区。• 静态成员变量一定要在类外初始化• 可以这样理解就是把一个全局变量放入了类中受到类域限制和管理但不存在某个具体对象中而是整个类的“全局”,所有的对象共用同一个static成员变量。• 静态成员变量不能在声明位置给缺省值初始化因为缺省值是去转到构造函数初始化列表的而静态成员变量不属于某个对象不走构造函数初始化列表。class A { public: A() { _count; } A(const A t) { _count; } ~A() { --_count; } int Get() { return _count; } private: //类中的声明 static int _count; }; //类外正式定义并初始化编译器为其分配内存 int A::_count 0; int main() { A a1, a2; A a3(a1); //在这里并没有显式的对_count去操作而是通过函数调用一并更改也能同时证明_count并不存在于某一对象中所有类对象共用一个_count cout a1.Get() endl; cout a2.Get() endl; return 0; }• 用static修饰的成员函数称之为静态成员函数静态成员函数没有this指针这也就导致其不可访问非静态成员不知道去访问哪个对象了。• 静态成员函数中可以访问静态成员但是不能访问非静态的因为没有this指针。• 非静态成员函数可以访问任意的静态成员变量和静态成员函数。• 突破类域就可以访问静态成员可以直接通过 类名::静态成员 或者 对象.静态成员来访问静态成员变量和静态成员函数。cout a1.Get() endl; cout A::Get() endl;• 静态成员也是类的成员受public、protected、private访问限定符的限制class A { public: A() { _count; } A(const A t) { _count; } ~A() { --_count; } static int Get() { return _count; } private: //类中的声明 static int _count; }; //类外正式定义并初始化编译器为其分配内存 int A::_count 0; int main() { cout A::Get() endl; A a1, a2; A a3(a1); cout a1.Get() endl; //支持用类名:: 去访问了 cout A::Get() endl; //编译报错error C2248: “A::_count”: 无法访问 private 成员(在“A”类中声明) //cout A::_count endl; return 0; }四.友元• 友元提供了一种突破类访问限定符封装的方法友元分为友元函数和友元类。在函数或类的声明前面放一个friend并把这个友元声明放入一个类的里面。class A { //友元函数和类的声明 friend int add(int x, int y); friend class B; public: private: int _a1 1; int _a2 2; }; class B { private: int _b 0; }; int add(int x, int y) { return x y; }• 外部友元函数/类可以访问类的私有和保护成员友元函数/类仅仅是一种声明他不是类的成员函数/类class A { //友元函数和类的声明 friend int add(const A a); public: A(int a1,int a2) :_a1(a1),_a2(a2) { } private: int _a1 1; int _a2 2; }; int add(const A a) { //add为A的友元函数可以之间访问A的私有 return a._a1 a._a2; } int main() { A aa1(4, 5); int sum add(aa1); cout sum endl; return 0; }• 友元声明可以写在类的任何地方其不受访问限定符限制class A { public: private: //友元函数和类的声明 friend int add(int x, int y); friend class B; int _a1 1; int _a2 2; }; class B { private: int _b 0; }; int add(int x, int y) { return x y; }• 一个类或函数可以是多个类的友元类或友元函数• 友元类中的成员函数都是另一个类的友元函数都可以访问另一个类中的私有和保护class A { //友元类的声明 friend class B; public: A(int a1,int a2) :_a1(a1),_a2(a2) { } private: int _a1 1; int _a2 2; }; class B { public: int add(const A a) { //add为A的友元函数可以之间访问A的私有 return a._a1 a._a2; } };这里B是A的友元类所以B中的add是A的友元函数。• 友元类的关系是单向的不具有交换性比如A类是B类的友元但是B类不是A类的友元。• 友元类的关系是单向的不具有交换性比如A类是B类的友元B类是C类的友元但是A类不是c类的友元。• 有时提供了便利。但是友元会增加耦合度破坏了封装所以友元不宜多用。五.内部类了解• 如果一个类定义在另一个类的内部这个在内部的类就叫做内部类。• 内部类是一个独立的类和定义在全局的类一样并不属于包含它的类算空间时算不上它跟定义在全局相比它只是受外部类的类域限制和访问限定符限制。这里和static成员有点像• 内部类默认是外部类的友元类即内部可以访问外部的私有和保护而默认外不可以访问内的。• 内部类本质也是一种封装当A类和B类紧密相连时A类实现出主要就是给B类用的则可以把A类设计成B的内部类再在B中写A类的友元声明如果放到private/protected位置那A就是B的专属内部类其他地方都不可以使用了。class A { private: static int _k; int _h 1; public: class B // B默认就是A的友元 { public: void foo(const A a) { cout _k endl; //OK cout a._h endl; //OK } int _b1; }; }; int A::_k 1; int main() { cout sizeof(A) endl; A::B b; A aa; b.foo(aa); return 0; }六.匿名对象• 用 “类型(实参)” 定义出来的对象叫匿名对象相比我们之前定义的“类型 对象名(实参)”定义出来的叫有名对象。int main() { //有名对象 A aa1(1, 2); //匿名对象 A(2, 3); return 0; }• 匿名对象生命周期只在当前一行其用处在于①一般定义一个对象当前用一下②我定义一个对象只为了调用其类内部的某个函数就可以定义匿名对象。int main() { //匿名对象 A(); A(1); //创建对象只为了调用函数 Solution().Sum_Solution(10); return 0; }