目录
1.构造函数补充
构造函数体赋值
在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值。
class Date { public: Date(int year, int month, int day) { _year = year; _month = month; _day = day; } private: int _year; int _month; int _day; };虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称作为类对象成员的初始化，构造函数体中的语句只能将其称作为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。
class Date { public: Date(int year = 2022, int month = 5, int day = 24) { _year = year; _year = 2023; //第二次赋值 _year = 2024; //第三次赋值 _month = month; _day = day; } private: int _year; int _month; int _day; };既然构造函数体的语句只能称作为赋初值，现在，可否有一种方式进行初始化呢？即初始化列表初始化。
初始化列表
初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。
class Date { public: //构造函数： -->初始化列表初始化 Date(int year = 2022, int month = 5, int day = 24) :_year(year) , _month(month) , _day(day) {} private: int _year; int _month; int _day; };当然，我可以在初始化列表初始化，也可以在大括号内进行赋值：
Date(int year = 2022, int month = 5, int day = 24) :_year(year) , _month(month) { _day = day; }
注意：
1、初始化列表可以认为就是对象成员变量定义的地方
2、每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
3、类中包含以下成员，必须放在初始化列表位置进行初始化：
---引用成员变量
---const成员变量
---自定义类型成员(该类没有默认构造函数)
4、尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。5、成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关
解释注意点2：
每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)Date(int year = 2022, int month = 5, int day = 24) :_year(year) , _year(month) // err {}
解释注意点3：
先前我们都知道引用的变量和const变量只能在定义时初始化，而普通的变量在定义时不强求初始化，所以引用成员变量和const成员变量必须在初始化列表进行初始化：class Date { public: //初始化列表可以认为就是对象成员变量定义的地方 Date(int year, int n, int ref) :_n(n) , _ref(ref) { _year = year; } private: //定义时不强求初始化，后面可再赋值修改 int _year; //声明 //只能在定义时初始化 const int _n; int& _ref; };自定义类型成员(该类没有默认构造函数)同样也得在初始化列表进行初始化：
class A { public: A(int x) //非默认构造函数，因为要主动传参 :_x(x) {} private: int _x; }; class Date { public: //在初始化列表对自定义类型 _aa 进行初始化 Date(int a) :_aa(a) {} private: A _aa; };注意这里的条件，一定得是没有默认构造函数的自定义类型成员才得在初始化列表进行初始化，而默认构造函数简单来说就是不需要传参的函数，这里简单回顾下：
1.我们没写编译器默认生成的构造函数
2.无参构造函数
3.全缺省构造函数
补充：如果自定义类型成员有默认构造，还需要在初始化列表里写吗？没必要，因为编译器会根据你定义成员变量的顺序，当走到自定义类型成员时自动调用其默认构造函数，如若你在初始化列表里对自定义类型初始化了，那么编译器会拿这个值作为形参传到其自定义类型的默认构造函数，继而输出的值为初始化列表里的值。
解释注意点5：
成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关
看下面这道题：
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(); }A、输出1 1 B、程序崩溃 C、编译不通过 D、1 随机值
答案：D
解析：注意我成员变量在类中声明次序就是其在初始化列表中的初始化顺序，既然_a2先声明，则必然进入初始化列表要先执行, _a2(_a1) 。意思是说拿_a1去初始化_a2，不过此时的_a1还是随机值，自然_a2即为随机值，随后执行:_a1(a)。拿a初始化_a1，所以输出的值为1和随机值。
explicit关键字
构造函数不仅可以构造与初始化对象，对于单个参数的构造函数，还具有类型转换的作用。
class Date
{
public:
Date(int year)
:_year(year)
{}
private:
int _year;
};
int main()
{
Date d1(2022); //构造
//隐式类型转换
Date d2 = 2022; //构造 + 拷贝构造 --》 优化成构造
}
//Date d3(d1); //拷贝构造
//Date d4 = d1;//拷贝构造这里Date d2 = 2022; 这段代码就利用到了C++的隐式类型转换，中间会产生一个临时对象，其本质是先拿2022构造一个Date类型的对象，再拿这个对象去拷贝构造给d2。可是编译器会对其直接进行优化，将整个过程直接就是构造。
C++为了避免隐式类型的转换，特地新增一个关键字：explicit，加上了这个关键字它就避免隐式类型转换的发生。此时再去编译，就会报错了。
2、static成员
概念
声明为static的类成员称为类的静态成员，分为如下两类：
用static修饰的成员变量，称之为静态成员变量
用static修饰的成员函数，称之为静态成员函数
静态的成员变量一定要在类外进行初始化
特性
-
1、静态成员为所有类对象所共享，不属于某个具体的实例
class A
{
private:
static int _n;
int _k;
char _a;
};
int main()
{
cout << sizeof(A) << endl; //8
return 0;
}这里的运行结果为8，这里的计算规则是按照C语言那套计算结构体大小的规则。并没有把我静态成员变量_n考虑进去，因为静态成员变量属于整个类，是类的所以对象，所以静态变量成员不计入总大小。
- 2、静态成员变量必须在类外定义，定义时不添加static关键字
class A
{
private:
//声明
static int _n;
static int _k;
};
//定义
int A::_n = 0;
int A::_k = 0;- 3、静态成员函数没有隐藏的this指针，不能访问任何非静态成员
class A
{
public:
static void Func()
{
cout << ret << endl; // err错误，访问了非静态成员，因为无this指针
cout << _k << endl; //正确
}
private:
//声明
int ret = 0;
static int _k;
};
//定义
int A::_k = 0;
- 4、访问静态成员变量的方式
当静态成员变量为公有时，可有如下三种进行访问：
- 通过对象.静态成员来访问
- 通过类名::静态成员来行访问
- 通过匿名对象突破类域进行访问
class A { public: static int _k; }; int A::_k = 0; int main() { A a; cout << a._k << endl; //通过对象.静态成员来访问 cout << A::_k << endl; //通过类名::静态成员来行访问 cout << A()._k << endl;//通过匿名对象突破类域进行访问 return 0; }当静态成员变量变成私有时，可采用如下方式：
1.通过对象.静态成员函数来访问
2.通过类名::静态成员函数来行访问
3.通过匿名对象调用成员函数进行访问class A { public: static int GetK() { return _k; } private: static int _k; }; int A::_k = 0; int main() { A a; cout << a.GetK() << endl; //通过对象.静态成员函数来访问 cout << A::GetK() << endl;//通过类名::静态成员函数来行访问 cout << A().GetK << endl; //通过匿名对象调用成员函数进行访问 return 0; }5、静态成员和类的普通成员一样，也有public、protected、private3种访问级别，也可以具有返回值
来看两个问题：
1、静态成员函数可以调用非静态成员函数吗？
答案：不可以，因为静态成员函数是没有this指针的，无法调用非静态成员函数。
2、非静态成员函数可以调用类的静态成员函数吗？
答案：可以，因为静态成员为所有类对象所共享，不受访问限制
3、友元
友元分为：友元函数和友元类
友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。
友元函数
说明如下：
- 友元函数可访问类的私有和保护成员，但不是类的成员函数
- 友元函数不能用const修饰，因为友元没有this指针
- 友元函数可以在类定义的任何地方声明，不受类访问限定符限制
- 一个函数可以是多个类的友元函数
- 友元函数的调用与普通函数的调用和原理相同
友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。
友元类
友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。
友元关系是单向的，不具有交换性。
比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。友元关系不能传递。
如果B是A的友元，C是B的友元，则不能说明C时A的友元。Date类里想访问我Time类里的私有成员，就让我Date变成你Time的友元类，相反我Time类里想访问Date类里的成员，就让我Time变成Date类的友元类，谁想访问谁，就要把谁设为谁的友元。
class Date; // 前置声明
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;
};4、内部类
概念及特性
概念：
如果一个类定义在另一个类的内部，这个内部类就叫做内部类。注意此时这个内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去调用内部类。外部类对内部类没有任何优越的访问权限。
注意：内部类就是外部类的友元类。注意友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。
特性：内部类可以定义在外部类的public、protected、private都是可以的。
注意内部类可以直接访问外部类中的static、枚举成员，不需要外部类的对象/类名。
sizeof(外部类) = 外部类，和内部类没有任何关系。
5、再次理解封装
现实生活中的实体计算机并不认识，计算机只认识二进制格式的数据。如果想要让计算机认识现实生活中的实体，用户必须通过某种面向对象的语言，对实体进行描述，然后通过编写程序，创建对象后计算机才可以认识。比如想要让计算机认识洗衣机，就需要：
1. 用户先要对现实中洗衣机实体进行抽象---即在人为思想层面对洗衣机进行认识，洗衣机有什么属性，有 那些功能，即对洗衣机进行抽象认知的一个过程
2. 经过1之后，在人的头脑中已经对洗衣机有了一个清醒的认识，只不过此时计算机还不清楚，想要让计 算机识别人想象中的洗衣机，就需要人通过某种面相对象的语言(比如：C++、Java、Python等)将洗衣机用类来进行描述，并输入到计算机中
3. 经过2之后,在计算机中就有了一个洗衣机类，但是洗衣机类只是站在计算机的角度对洗衣机对象进行 描述的，通过洗衣机类，可以实例化出一个个具体的洗衣机对象，此时计算机才能洗衣机是什么东西。
4. 用户就可以借助计算机中洗衣机对象，来模拟现实中的洗衣机实体了。
在类和对象阶段，大家一定要体会到，类是对某一类实体(对象)来进行描述的，描述该对象具有那些属性， 那些方法，描述完成后就形成了一种新的自定义类型，才用该自定义类型就可以实例化具体的对象。
6、再次理解面向对象
418
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
