---

二、类和对象

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语言保持一致。

其中数据段也叫做静态区，代码段也叫做常量区。

1. 栈又叫堆栈–非静态局部变量/函数参数/返回值等等，栈是向下增长的。
2. 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信。
3. 堆用于程序运行时动态内存分配，堆是可以上增长的。
4. 数据段–存储全局数据和静态数据。
5. 代码段–可执行的代码/只读常量。

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大小的空间并且初始化为3int* 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 不会。

---

未完待续