(学习总结12)C++类和对象3

以下代码环境在 VS2022。

一、初始化列表

1. 之前我们实现构造函数时，初始化成员变量主要使用函数体内赋值，构造函数初始化还有⼀种方式，就是初始化列表，初始化列表的使用方式是以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个 " 成员变量 " 后面跟一个放在括号中的初始值或表达式。

2. 每个成员变量在初始化列表中只能出现一次，语法理解上初始化列表可以认为是每个成员变量定义初始化的地方。

3. 引用成员变量，const 成员变量，没有默认构造的类类型变量，必须放在初始化列表位置进行初始化，否则会编译报错。

4. C++11 支持在成员变量声明的位置给缺省值，这个缺省值主要是给没有显示在初始化列表初始化的成员使用的。

5. 尽量使用初始化列表初始化，因为那些不在初始化列表初始化的成员也会走初始化列表，如果这个成员在声明位置给了缺省值，初始化列表会用这个缺省值初始化。如果没有给缺省值，对于没有显示在初始化列表初始化的内置类型成员是否初始化取决于编译器，C++ 并没有规定。对于没有显示在初始化列表初始化的自定义类型成员会调用这个成员类型的默认构造函数，如果没有默认构造会编译错误。

6. 初始化列表中按照成员变量在类中声明顺序进行初始化，跟成员在初始化列表出现的的先后顺序无关，建议声明顺序和初始化列表顺序保持一致。

#include <iostream>
using namespace std;class Time
{
public:Time(int a) : _time(a){cout << "time" << endl;}void print(){cout << _time << endl;}private:int _time;};class Date
{
public:Date(int& a, int year = 2000, int month = 1, int day = 1):_year(year),_month(month),_day(day),_hour(20),_a(a),_n(1){// 引用成员变量，const 成员变量，// 没有默认构造的类类型变量，// 必须放在初始化列表位置进行初始化，// 否则会编译报错}void print(){cout << _year << " " << _month << " " << _day << " ";_hour.print();cout << " " << _a << " " << _n;}private:int _year;int _month;int _day;Time _hour;int& _a;const int _n;};int main()
{int x = 10;Date d1(x);d1.print();return 0;
}

class Date
{
public://...private:// 注意这⾥不是初始化，这⾥给的是缺省值，// 这个缺省值是给初始化列表的，// 如果初始化列表没有显⽰初始化，// 默认就会⽤这个缺省值初始化int _year = 1000;int _month = 12;int _day = 12;Time _hour = 10;int& _a = _year;const int _n = 5;};

二、类型转换

1. C++ 支持 内置 类型隐式转换为 类 类型对象，需要有相关内置类型为参数的构造函数。
2. 构造函数前面加 explicit 就不再支持隐式类型转换。

#include<iostream>
using namespace std;class A
{
public:// 构造函数explicit就不再⽀持隐式类型转换// explicit A(int a1)A(int a1):_a1(a1){;}//explicit A(int a1, int a2)A(int a1, int a2):_a1(a1), _a2(a2){;}void print(){cout << _a1 << " " << _a2 << endl;}private:int _a1 = 1;int _a2 = 2;};int main()
{// 1构造⼀个A的临时对象，再⽤这个临时对象拷⻉构造aa3// 编译器遇到连续构造+拷⻉构造->优化为直接构造A aa1 = 1;aa1.print();const A& aa2 = 1;// C++11之后才⽀持多参数转化A aa3 = { 2,2 };aa3.print();return 0;
}

三、static成员

1. 用 static 修饰的成员变量，称之为静态成员变量，静态成员变量不加 const 一定要在类外进行初始化。

2. 静态成员变量为所有类对象所共享，不属于某个具体的对象，不存在对象中，存放在静态区。

3. 用 static 修饰的成员函数，称之为静态成员函数，静态成员函数没有 this 指针。

4. 静态成员函数中可以访问其他的静态成员，但是不能访问非静态的，因为没有 this 指针。

5. 非静态的成员函数，可以访问任意的静态成员变量和静态成员函数。

6. 突破类域就可以访问静态成员，可以通过 类名::静态成员 或者 对象.静态成员 来访问静态成员变量和静态成员函数。

7. 静态成员也是类的成员，受public、protected、private 访问限定符的限制。

8. 静态成员变量在不加 const 不能在声明位置给缺省值初始化。缺省值是用于构造函数初始化列表的，静态成员变量不属于某个对象，不走构造函数初始化列表。

// 实现⼀个类，计算程序中创建出了多少个类对象？
#include<iostream>
using namespace std;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;int main()
{cout << A::GetACount() << endl;A a1, a2;A a3(a1);cout << A::GetACount() << endl;cout << a1.GetACount() << endl;// 编译报错，⽆法访问 private 成员//cout << A::_scount << endl;return 0;
}

四、友元

1. 友元提供了一种突破类访问限定符封装的方式，友元分为：友元函数和友元类，在函数声明或者类声明的前面加 friend，并且把友元声明放到一个类的里面。

2. 外部友元函数可访问类的私有和保护成员，友元函数仅仅是一种声明，他不是类的成员函数。

3. 友元函数可以在类定义的任何地方声明，不受类访问限定符限制。

4. 一个函数可以是多个类的友元函数。

5. 友元类中的成员函数都可以是另一个类的友元函数，都可以访问另一个类中的私有和保护成员。

6. 友元类的关系是单向的，不具有交换性，比如 A 类是 B 类的友元，但是 B 类不是 A 类的友元。

7. 友元类关系不能传递，如果 A 是 B 的友元，B 是 C 的友元，但是 A 不是 B 的友元。

8. 有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。

#include<iostream>
using namespace std;// 前置声明，都则A的友元函数声明编译器不认识B
class B;class A
{// 友元声明friend void func(const A& aa, const B& bb);private:int _a1 = 1;int _a2 = 2;};class B
{// 友元声明friend void func(const A & aa, const B & bb);private:int _b1 = 3;int _b2 = 4;};void func(const A& aa, const B& bb)
{cout << aa._a1 << endl;cout << bb._b1 << endl;
}int main()
{A aa;B bb;func(aa, bb);return 0;
}

#include<iostream>
using namespace std;class A
{// 友元声明friend class B;private:int _a1 = 1;int _a2 = 2;};class B
{
public:void func1(const A& aa){cout << aa._a1 << endl;cout << _b1 << endl;}void func2(const A& aa){cout << aa._a2 << endl;cout << _b2 << endl;}private:int _b1 = 3;int _b2 = 4;};int main()
{A aa;B bb;bb.func1(aa);bb.func1(aa);return 0;
}

五、内部类

1. 如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，跟定义在全局相比，他只是受外部类类域限制和访问限定符限制，所以外部类定义的对象中不包含内部类。

2. 内部类默认是外部类的友元类。

3. 内部类本质也是一种封装，当 A 类跟 B 类紧密关联，A 类实现出来主要就是给 B 类使用，那么可以考虑把 A 类设计为 B 的内部类，如果放到 private / protected 位置，那么 A 类就是 B 类的专属内部类，其他地方都用不了。

#include<iostream>
using namespace std;class A
{
private:static int _k;int _h = 1;public:class B		// B默认就是A的友元{public:void foo(const A& a){cout << _k << endl;			cout << a._h << endl;		}};
};int A::_k = 1;int main()
{cout << sizeof(A) << endl;A::B b;A aa;b.foo(aa);return 0;
}

六、匿名对象

1. 用 “ 类型(实参) ” 定义出来的对象叫做匿名对象，相比之前我们定义的 “ 类型 对象名(实参) ” 定义出来的叫有名对象。

2. 匿名对象生命周期只在当前一行，一般临时定义一个对象当前用一下即可，就可以定义匿名对象。

#include <iostream>
using namespace std;class A
{
public:A(int a = 0):_a(a){cout << "A(int a)" << endl;}~A(){cout << "~A()" << endl;}private:int _a;};class Solution {public:int Sum_Solution(int n) {//...return n;}
};
int main()
{A aa1; // 不能这么定义对象，因为编译器⽆法识别下⾯是⼀个函数声明，还是对象定义//A aa1();// 但是我们可以这么定义匿名对象，匿名对象的特点不⽤取名字，// 但是他的⽣命周期只有这⼀⾏，我们可以看到下⼀⾏他就会⾃动调⽤析构函数A();A(1);A aa2(2);// 匿名对象在这样场景下就很好⽤Solution().Sum_Solution(10);return 0;
}