---

二、类和对象

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

---

未完待续