二、类和对象
20. 友元
1. 友元函数
我们在实现日期类的时候也实现了重载 operator<< 和 operator>> ，但是由于 this指针 位于形参的第一个位置，我们不得不将这个重载函数设成全局函数，但是全局函数又不能访问类的私有成员变量。我们是怎么解决这个问题的呢？是的，我们将这个函数的声明放在类内，然后在前面加上 friend 关键字，使其成为友元函数，友元函数就能够在类外访问类的私有成员变量了。
友元函数突破了封装，提供了便利，但这一定是好的吗？类的封装是非常重要的，友元函数能不使用就不使用。
友元函数可访问类的私有和保护成员，但不是类的成员函数
友元函数不能用const修饰
友元函数可以在类定义的任何地方声明，不受类访问限定符限制
一个函数可以是多个类的友元函数
友元函数的调用与普通函数的调用原理相同
2.友元类
友元不仅有友元函数，还有友元类。
class Time { // 将日期类声明成友元类 friend class Date; public: Time(int hour = 0, int minute = 0, int second = 0) : _hour(hour) , _minute(minute) , _second(second) {} private: int _hour; int _minute; int _second; };
在上面的时间类中，友元了一个日期类，这代表 时间类认为日期类是它的朋友，所以日期类可以任意访问时间类的成员函数和成员变量 。但是！假如日期类里面并没有将时间类声明成友元类的话，时间类则不能访问日期类的私有成员 。友元的关系是单向的，我是你的朋友并不代表你是我的朋友。
友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。
友元关系是单向的，不具有交换性。
友元关系不能传递。如果C是B的友元， B是A的友元，则不能说明C时A的友元。
友元关系不能继承。
21. 内部类
如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。
class A { public: // 内部类 class B { public: void foo(const A& a) { cout << k << endl; cout << a.h << endl; } }; private: static int k; int h; };
其实内部类又有什么特殊的，只是 B 这个类受 类A 的类域的限制，必须先访问 类A 的域才能访问到 类B ，其次就是 内部类天生就是外部类的友元类 ，内部类能够访问到外部类的私有成员，外部类却访问不到内部类的私有成员。
注意：sizeof(外部类)=外部类，和内部类没有任何关系 。
22. 匿名对象
匿名对象就是没有名字的对象，生命周期只有一行 。这个对象一行内完成构造和析构。
#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; }; int main() { // 有名对象 A aa1; A aa2(2); // 匿名对象 A(); A(3); return 0; }
匿名对象的作用是什么呢？匿名作用适合用来传参，不需要取名字，消亡的快。但是有名函数通通可以做到😂。
class Solution { public: int Sum_Solution(int n) { //... return n; } }; int main() { // 匿名对象的使用 Solution().Sum_Solution(10); return 0; }
23. 拷贝对象时的一些编译器优化
在传参和传返回值的过程中，一般编译器会做一些优化，减少对象的拷贝，这个在一些场景下还是非常有用的。每个编译器优化的程度不一样，所以这部分了解即可。
#include<iostream> using namespace std; class A { public: // 构造 A(int a = 0) :_a(a) { cout << "A(int a)" << endl; } // 拷贝构造 A(const A& aa) :_a(aa._a) { cout << "A(const A& aa)" << endl; } // 赋值重载 A& operator=(const A& aa) { cout << "A& operator=(const A& aa)" << endl; if (this != &aa) { _a = aa._a; } return *this; } // 析构 ~A() { cout << "~A()" << endl; } private: int _a; }; void f1(A aa) {} A f2() { A aa; return aa; } int main() { // 传值传参 A aa1; f1(aa1); cout << endl; // 传值返回 f2(); cout << endl; // 隐式类型，连续构造+拷贝构造->优化为直接构造 f1(1); // 一个表达式中，连续构造+拷贝构造->优化为一个构造 f1(A(2)); cout << endl; // 一个表达式中，连续拷贝构造+拷贝构造->优化一个拷贝构造 A aa2 = f2(); cout << endl; // 一个表达式中，连续拷贝构造+赋值重载->无法优化 aa1 = f2(); cout << endl; return 0; }
每个编译器优化程度不一样，结果不同也不要担心。
三、内存管理
1. C/C++内存分布
C++的内存分布和C语言保持一致。
其中数据段也叫做静态区，代码段也叫做常量区。
- 栈又叫堆栈–非静态局部变量/函数参数/返回值等等，栈是向下增长的。
- 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信。
- 堆用于程序运行时动态内存分配，堆是可以上增长的。
- 数据段–存储全局数据和静态数据。
- 代码段–可执行的代码/只读常量。
2. C语言中动态内存管理方式：malloc/calloc/realloc/free
void Test () { int* p1 = (int*) malloc(sizeof(int)); free(p1); // 1.malloc/calloc/realloc的区别是什么？ int* p2 = (int*)calloc(4, sizeof (int)); int* p3 = (int*)realloc(p2, sizeof(int)*10); // 2.这里需要free(p2)吗？ free(p3); }
1.malloc是分配内存，并不初始化内容；calloc是分配内存，但是将内容初始化为0；realloc是重新分配内存，可以在原本的内存上扩容，不初始化。
2.不需要，因为内存并没有增加，属于原地扩容，此时p3和p2指向同一片空间，释放一个即可。
3. C++内存管理方式
C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力，而且使用起来比较麻烦，因此C++又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。
#include<iostream> using namespace std; int main() { int* p1 = (int*)malloc(sizeof(int)); // p2指向一个int大小的空间 int* p2 = new int; // 指向10个int大小的空间 int* p3 = new int[10]; // 指向一个int大小的空间并且初始化为3 int* p4 = new int(3); // 指向10个int大小的空间并把前5个初始化为。。。 int* p5 = new int[10] { 1, 2, 3, 4, 5}; free(p1); delete p2; delete[] p3; delete p4; delete[] p5; return 0; }
在C语言中，malloc 和 free 俩个都是函数，而C++里， new 和 delete 则是两个关键字。new 非常好用，自动识别类型和个数，在用法上，new 更加简洁，且还可以控制初始化。如果是自定义类型，new 则会开空间并且调用自定义类型的构造函数。new 开空间失败了会抛异常，不需要手动检查。
申请和释放单个元素的空间，使用 new 和 delete 操作符，申请和释放连续的空间，使用 new[] 和 delete[]。注意：需要匹配起来使用。
在申请自定义类型的空间时，new 会调用构造函数，delete 会调用析构函数，而 malloc 与 free 不会。
