【C++】类和对象

文章目录

• [1. 为什么引入类？](#1. 为什么引入类？)
• • [1.1 C++类的设计目标](#1.1 C++类的设计目标)
  • [1.2 类的核心特性](#1.2 类的核心特性)
  • [1.3 类与结构体的区别](#1.3 类与结构体的区别)
• [2. 类的定义](#2. 类的定义)
• • [2.1 类定义格式](#2.1 类定义格式)
  • [2.2 访问限定符](#2.2 访问限定符)
  • [2.3 类域](#2.3 类域)
• [3. 实例化](#3. 实例化)
• • [3.1 实例化概念](#3.1 实例化概念)
  • [3.2 对象大小](#3.2 对象大小)
• [4. this指针](#4. this指针)
• [5. 类的默认成员函数](#5. 类的默认成员函数)
• [6. 构造函数](#6. 构造函数)
• [7. 析构函数](#7. 析构函数)
• [8. 拷贝构造函数](#8. 拷贝构造函数)
• [9. 赋值运算符重载](#9. 赋值运算符重载)
• • [9.1 运算符重载](#9.1 运算符重载)
  • [9.2 赋值运算符重载](#9.2 赋值运算符重载)
• [10. 取地址运算符重载](#10. 取地址运算符重载)
• • [10.1 const 成员函数](#10.1 const 成员函数)
  • [10.2 取地址运算符重载](#10.2 取地址运算符重载)
• [11. 构造函数的初始化列表](#11. 构造函数的初始化列表)
• [12. 类型转换](#12. 类型转换)
• [13. static 成员](#13. static 成员)
• [14. 友元](#14. 友元)
• [15. 内部类](#15. 内部类)
• [16. 匿名对象](#16. 匿名对象)

1. 为什么引入类？

C++中类的引入是面向对象编程（OOP）的核心，它通过封装数据与操作、继承和多态等机制，彻底改变了代码的组织方式。

1.1 C++类的设计目标

1. 解决C语言的结构体局限性
   • C语言的struct仅能定义数据成员，无法直接绑定操作（函数）。
2. 支持面向对象三大特性
   • 封装：隐藏实现细节，暴露安全接口。
   • 继承：实现代码复用和层次化设计。
   • 多态：允许不同对象对同一消息做出不同响应。

1.2 类的核心特性

1. 成员访问

访问修饰符	作用域
public	公开访问（类外可见）
private	仅类内和友元访问（默认）
protected	类内、派生类及友元访问

2. 构造函数与析构函数
   • 构造函数：初始化对象（支持重载）。
   • 析构函数：释放资源（如内存、文件句柄）。
3. 静态成员
   • 静态数据成员：类所有实例共享。
   • 静态成员函数：不依赖对象实例，只能访问静态成员。
4. 友元（Friends）
   • 允许特定函数或类访问私有成员（破坏封装，谨慎使用）。
5. 运算符重载
   • 自定义类对象运算符的行为。

1.3 类与结构体的区别

特性	class	struct
默认访问权限	private	public
设计意图	封装复杂逻辑	轻量级数据聚合
继承默认权限	private（除非显式指定）	public（除非显式指定）

2. 类的定义

2.1 类定义格式

• class 为定义类的关键字，后面接类的名字，再接{}，{}中为类的主体，注意定义类和定义结构体一样，后面的的分号不能省略。类中内容称为类的成员：类中的变量称为类的属性或成员变量；类中的函数称为成员函数。
• 为了区分成员变量，一般习惯上成员变量会加一个特殊标识，个人习惯在成员变量前面加_。
• C++中 struct 也可以定义类，C++兼容 C 中 struct 的用法，同时 strcut 升级成了类，明显的变化是 struct 中可以定义函数，但是类默认权限是 private，而结构体默认权限是 public。一般情况下，还是推荐使用 class 定义类。
• 类的成员函数默认为 inline。

定义一个学生类：

class student
{
public:
	// 成员函数
	void eat()
	{
	}
	void play()
	{
	}
	void study()
	{
	}

private:
	// 成员变量
	int _height;
	int _weight;
	int _age;
	int _id;
	string _name;
};

2.2 访问限定符

• C++⼀种实现封装的方式，用类将对象的属性与方法结合在一块，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用。
• 访问限定符有三种 public（公共的）、protected（受保护的）、private（私有的）。
• public 修饰的成员在类外可以直接被访问；protected 和 private 修饰的成员在类外不能直接被访问，后续继承再将它们的区别。
• 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止，如果后续没有访问限定符，作用域就到类结束。
• 一般成员变量都会被限制为 private/protected，需要给别人访问的成员函数会放为 public。以此来保证数据的安全。

2.3 类域

• 类定义了一个新的作用域，类的所有成员都在类的作用域中，当我们在类外定义成员时，需要用 :: 作用域操作符指明类属于哪个类域。

具体使用在我们头源文件分离的时候。我们在头文件定义好类的成员变量，声明好成员函数，再在源文件中实现成员函数的定义。

class Stack
{
public:
	void Init(int n = 4);
private:
	int* _arr;
	size_t _capacity;
	size_t _top;
}

// 声明和定义分离，需要指定类域
void Stack::Init(int n)
{
	arr = (int*)malloc(sizeof(int) * n);
	if (nullptr == arr)
	{
		perror("malloc failed");
		return;
	}
	_capacity = n;
	top = 0;
}

3. 实例化

3.1 实例化概念

• 用类类型在物理内存中创建对象的过程，称为类实例化对象。
• 类是对像进行一种抽象描述，是一个模型一样的东西，限定了类有哪些成员变量，这些成员变量只是声明，并没有分配空间，要在用类实例化对象时，才会分配空间。（成员函数在编译期就确定，并存储在代码区中，即使未实例化，这些函数也已经在内存中）
• 类就像是图纸，本身并不占什么空间，要通过其建造出来实际的物品，这实际的物品才会占用空间。

3.2 对象大小

类实例化出的对象会包含成员函数吗？不会！函数被编译后只是一段指令，对象中没法存储，存储在代码区。非要存储只能存储函数指针。那么函数指针需要存储吗？如果实例化多个对象，如果每个对象中都包含这些成函数指针，这些函数指针都相同，有必要在每个对象中都存储吗？很明显会造成空间浪费，所以不需要存储。编译器在编译链接时，就要找到函数的地址。

既然成员函数变量不需要存储，那么类对象的大小怎么计算呢？

和结构体一样，成员变量需要遵守内存对齐规则。

回顾一下：
内存对齐规则

• 第一个成员变量在与结构体偏移量为 0 的地址处。
• 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
• 注意：对齐数 = 编译器默认的一个对齐数 与 该成员变量大小的较小值。
• VS 中默认的对齐数为 8。
• 结构体总大小 = 最大对齐数（所有变量类型最大者与默认对齐参数最小）的整数倍。
• 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

注意：

在对象没有成员变量的时候，实例化出来的对象大小为1。这里给 1 字节，纯粹是为了占位标识对象存在。如果一个字节都不给，你怎么知道对象存在不存在？

4. this指针

• 当存在多个对象去调用成员函数的时候，该函数是怎么知道到底是哪个对象调用了它？其实C++存在一个隐含的 this 指针。
• 编译器编译后，类的成员函数都会默认在形参第一个位置增加一个当前类型的指针，叫做 this 指针。比如 Data类的 Init 的真实原型为 void Init(Data* const this, int year, int month, int day)
• 类的成员函数中访问成员变量，本质是通过 this 指针访问的，如 Init 函数给 _year 赋值，本质上是 this->_year = year;
• C++ 规定不能在实参和形参的位置显示写 this 指针（编译时编译器会处理），但是可以在函数体内显示使用 this 指针。

class Data
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		this->_day = day;
	}
	void Print()
	{
		cout << _year << "/" << _month << _day << endl;
	}

private:
	int _year;
	int _month;
	int _day;
};

5. 类的默认成员函数

一个类，我们不写的情况下，编译器会默认生成以下六个默认成员函数，需要注意的是这6个中最重要的是前四个，后两个取地址重载不重要。后续 C++11 以后还会增加两个默认成员函数，移动构造和移动赋值，后续 C++11 再讲。我们从以下两个方面去学习默认成员函数：

• 第一：我们不写时，编译器默认生成的函数行为是什么，是否满足我们的需求。
• 第二：编译器默认生成的函数不满足我们的需求，我们需要自己实现，那么如何自己实现。

六个默认成员函数：

• 初始化和清理
  • 构造函数主要完成初始化工作
  • 析构函数主要完成清理工作
• 拷贝复制
  • 拷贝构造是使用同类对象初始化创建对象
  • 赋值重载主要是把一个对象赋值给另一个对象
• 取地址重载 （这两个很少会自己实现）
  • 普通对象取地址
  • const 对象取地址

6. 构造函数

构造函数是特殊的成员函数，需要注意的是，构造函数并不是开辟空间创建对象（局部对象是在栈帧创建时，空间就开好了），而是对象实例化时初始化对象。构造函数的本质是要替代掉 Init 函数的功能，构造函数在我们创建对象时就会自动调用而非手动调用，这就非常方便了。（但是后面你会发现，其实构造函数和 Init 函数分开写也有好处，能提高代码的灵活性、可维护性。而且构造函数只能抛出异常，无法返回错误码，在错误处理上也会更方便）

构造函数的特点：

1. 函数名与类名相同。（很合理吧，我们创建对象的时候使用类名，然后因为是同名就自动调用构造函数）
2. 无返回值。（啥返回值都不需要给，也不需要写 void，构造函数是实例化的时候自动调用的，要返回值干嘛？）
3. 对象实例化时系统会自动调用对应的构造函数。
4. 构造函数可以重载。
5. 如果类中没有定义构造函数，则 C++ 编译器会自动生成一个无参的默认构造函数，一旦用户显示定义编译器将不再生成。
6. 无参构造函数、全缺省构造函数、我们不写构造时编译器默认生成的构造函数，都叫做默认构造函数。但是这三个只会存在一个，不能同时存在。我们不写构造时 C++ 编译器默认生成的构造函数其实就是无参构造函数。无参构造和全缺省构造同时存在会造成的问题是会存在歧义，编译器无法得知你到底是要调用哪个构造函数。**注意：**这三个构造函数都可以叫做默认构造，因为它们都是不需要传参的构造函数，我对默认构造的理解就是，我只是实例化一个对象，至于到底要怎么构造我不管（不传参），就让编译器自己决定的就是默认构造。

这里说一个比较有意思的

我在这里明明自己写了带参数的构造函数，为什么在 main 函数中使用 zkp z() 这样的方式不会报错呢？

• 事实上，在 C++ 中，这样的写法会被编译器解析为 **声明一个名为 z 的函数，该函数无参且返回 zkp 类型的对象。
• 所以，这并不是创建 zkp 类的对象，实际上没有调用任何构造函数，因此不会触发构造函数相关错误。
• 真正调用默认构造函数的方式是 zkp z; 这样不带括号的方式。

7. 析构函数

析构函数与构造函数功能相反，析构函数并不是完成对对象本身的销毁，比如局部对象，它是在创建栈上的，函数结束栈帧销毁，它就自动释放了，不需要我们管，C++ 规定对象在销毁时自动会调用析构函数，完成对象中资源的清理释放工作。这里所说的资源如堆内存、文件句柄、网络连接等。

析构函数特点：

1. 析构函数名是在类名前加上字符~。
2. 无参数无返回值。（这里和构造类似，不需要 void）
3. 一个类只能有一个析构函数。若未显示定义，系统会自动生成默认的析构函数。
4. 对象生命周期结束时，系统会自动调用析构函数。
5. 跟构造函数类似，我们不写编译器会自动生成的析构函数对内置类型成员不做处理，自定义类型成员会调用它的析构函数。
6. 还需要注意的是我们显示写析构函数，对于自定义类型成员也会调用它的析构，也就是说自定义类型成员无论什么情况都会自动调用析构函数。
7. 如果类中没有申请资源时，析构函数可以不写，编译器自己默认生成的析构函数就已经够用了。但是如果申请了资源，如 malloc 了一段堆内存，那么就一定需要手动实现析构函数，否则会造成资源泄露。
8. 一个局部域的多个对象，C++ 规定后定义的先析构。这里看一段代码及运行结果图
   
   A、B、C、D四个对象是按照顺序定义的，其中 A、B 是全局变量，而 C、D 是局部变量。
   局部域中的变量先先销毁，且 D 是定义在 C 的后面，所以 D 先销毁，而 C 紧随其后。
   接着就是两个全局变量，同理，B 先销毁，再销毁 A。
   为什么会这样呢？同样很简单，因为栈帧！先创建的变量要先入栈，后创建的变量后入栈，那么在销毁对象的时候是按照不断地销毁栈顶变量。

8. 拷贝构造函数

如果一个构造函数的第一个参数是自身类型的引用，且任何额外的参数都有默认值，则此构造函数也叫做拷贝构造函数，也就是说拷贝构造是一个特殊的构造函数。

拷贝构造的特点：

1. 拷贝构造函数是构造函数的一个重载
2. 拷贝构造函数的参数只有一个且必须是类类型的引用，使用传值方式编译器直接报错，语法逻辑上引发了无穷递归调用。
3. C++规定自定义类型对象进行拷贝行为必须调用拷贝构造，所以这里自定义类型传值传参和传值返回都会调用拷贝构造完成。
4. 若未显示定义拷贝构造，编译器会自动生成拷贝构造函数。自动生成的拷贝构造对内置类型成员会完成值拷贝/浅拷贝（按字节拷贝），对自定义成员变量会调用它的拷贝构造。
5. 申请了资源的类，需要我们自己手动去实现深拷贝（对指向的资源也进行拷贝）。
6. 传值返回会产生一个临时对象调用拷贝构造，传引用返回，返回的是对象的别名（引用），没有产生拷贝。但是如果返回的对象是一个当前函数局部域的局部对象，那么使用引用返回是有问题的，这时的引用相当于一个野引用，类似于野指针。传引用返回可以减少拷贝，但是一定要确保返回对象，在当前函数结束后还在！

假设这里存在日期类，如果进行传值调用拷贝构造

在 C++ 中，拷贝构造函数传值会导致无限递归的根本原因是：参数传递的本质是对象复制，而对象复制的过程又会触发拷贝构造函数本身，形成逻辑闭环。

1. 参数传递的本质
   当参数是值传递（而非引用）时，编译器会生成一个实参的副本，并将副本传递给参数。例如：

void func(Class obj);  // 值传递参数

Class a;
func(a);  // 调用 func 时，编译器会生成 a 的副本

但是为了生成 a 的副本，其实编译器是通过调用 Class 中的拷贝构造来构造 a。（其实就是因为这个）

2. 拷贝构造函数本身的参数传递
   如果拷贝构造函数的参数也是值传递

class Class 
{
public:
    // 错误写法：参数是值传递！
    Class(Class other) { /* ... */ }
};

Class a;
Class b = a;  // 调用拷贝构造函数 Class::Class(Class other)

此时编译器需要将 实参 a 复制给形参 other。为了完成这个复制操作，会触发对应 Class::Class(Class other) 的调用。

3. 递归调用链的形参
   具体如下：

1. 第一次调用：Class b = a → 需要调用 Class::Class(Class other)。
2. 复制实参：为了传递 other 参数，需要将 a 复制到 other → 调用 Class::Class(Class other)。
3. 再次复制实参：复制 a 到 other 的过程中，又需要调用 Class::Class(Class other)。
4. 无限循环：每次调用拷贝构造函数都会触发下一次拷贝构造，直至栈溢出崩溃。

9. 赋值运算符重载

9.1 运算符重载

• 当运算符被用于类类型的对象时，C++语言允许我们通过运算符重载的形式指定新的含义。C++规定类类型对象使用运算符时，必须转换成调用对应运算符重载，若没有对应的运算符重载，则会编译报错。
• 运算符重载是具有特名字的函数，他的名字是由 operator和后面要定义的运算符 共同构成。和其他函数一样，它也具有其返回类型和参数列表以及函数体。
• 重载运算符函数的参数个数和该运算符作用的运算对象数量一样多。一元运算符有一个参数，二元运算符有两个参数，二元运算符的左侧运算对象传给第一个参数，右侧运算对象传给第二个参数。
• 如果一个重载运算符函数是成员函数，则它的第一个运算对象默认传给隐式的this指针，因此运算符重载作为成员函数时，参数比运算对象少一个。
• 运算符重载以后，其优先级和结合性与对应的内置类型运算符保持一致。不能通过连接语法中没有的符号来创建新的操作符：比如operator@。
• .* :: sizeof ?: .注意以上5个运算符不能重载。
• 重载操作符至少有一个类类型参数，不能通过运算符重载改变内置类型对象的含义，如：int operator+(int x, int y)
• 一个类需要重载哪些运算符，是看哪些运算符重载后有意义，比如Date类重载operator-就有意义，但是重载operator+就没有意义。
• 重载++运算符时，有前置++和后置++，运算符重载函数名都是operator++，无法很好的区分。C++规定，后置++ 重载时，增加⼀个 int形参，跟前置++构成函数重载，方便区分。
• 重载<<和>>时，需要重载为全局函数，因为重载为成员函数，this指针默认抢占了第⼀个形参位置，第⼀个形参位置是左侧运算对象，调用时就变成了 对象<<cout，不符合使用习惯和可读性。重载为全局函数ostream/istream放到第⼀个形参位置就可以了，第⼆个形参位置当类类型对象。

这里就简单实现一下重载 << 和 >>，感觉就这两个容易忘，剩下的可以自己去尝试下实现。

class student
{
public:
	// 友元函数声明
	friend ostream& operator<<(ostream& out, const student& d);
	friend istream& operator>>(istream& in, student& d);
	// 也可以通过提供 getter、setter实现非友元版本，但是代码比较冗余
private:
	int _age;
	string _name;
	int _id;
};

ostream& operator<<(ostream& out, const student& s);
istream& operator>>(istream& in, student& s);

ostream& operator<<(ostream& out, const student& s)
{
	out << "姓名：" << s._name << " 年龄：" << s._age << " 学号：" << s._id << endl;
}

istream& operator>>(istream& in, student& s)
{
	in >> s._name >> s._age >> s._id;
}

9.2 赋值运算符重载

赋值运算符重载是⼀个默认成员函数，用于完成两个已经存在的对象直接的拷贝赋值，这里要注意跟拷贝构造区分，拷贝构造用于⼀个对象拷贝初始化给另⼀个要创建的对象。

赋值运算符重载特点：

• 赋值运算符重载是一个运算符重载，规定必须重载为成员函数。赋值运算重载的参数建议写成 const当前类类型引用，否则会传值传参会有拷贝
• 有返回值，且建议写成当前类类型引用，引用返回可以提高效率，有返回值目的是为了支持连续赋值场景。
• 没有显式实现时，编译器会自动生成一个默认赋值运算符重载，默认赋值运算符重载行为跟默认构造函数类似，对内置类型成员变量会完成值拷贝/浅拷贝（一个字节一个字节的拷贝)，对自定义类型成员变量会调用他的拷贝构造。

这个也是自己需要自己去尝试写代码，死记硬背没什么用，自己多实践印象才会深刻。

10. 取地址运算符重载

10.1 const 成员函数

• 将 const 修饰的成员函数称之为 const成员函数，const 修饰成员函数放到成员函数参数列表的后面。（没办法，没地方放了，放在类型、变量前面直接修改语义了）
• const 实际修饰该成员函数隐含的 this 指针，表明在该成员函数中不能对类的任何成员进行修改。const 修饰Date 类的 Print 成员函数，Print 隐含的 this 指针由 Date* const this 变为 const Date* const this。
• const 成员函数可以被普通对象和 const 对象调用，而 普通成员函数 只能被普通对象调用，不能被 const 对象调用。（还是那句话，权限可以缩小，但是不能放大）

10.2 取地址运算符重载

取地址运算符重载分为 普通取地址运算符重载 和 const取地址运算符重载 ，⼀般这两个函数编译器自动生成的就可以够我们用了，不需要去显示实现。除非⼀些很特殊的场景，比如我们不想让别人取到当前类对象的地址，就可以自己实现⼀份，胡乱返回⼀个地址。

11. 构造函数的初始化列表

• 前面我们实现构造函数时，初始化成员变量主要使用函数体内赋值，构造函数初始化还有一种方式，就是初始化列表，初始化列表的使用方式是以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。
• 每个成员变量在初始化列表中只能出现一次，语法理解上初始化列表可以认为是每个成员变量定义初始化的地方。
• 引用成员变量，const 成员变量，没有默认构造的类类型变量，必须放在初始化列表位置进行初始化，否则会编译报错。（引用必须在初始化时绑定一个对象；const 在定义时就必须初始化，之后不可修改；对于类变量，编译器会尝试使用它的默认构造函数进行构造，但如果它不存在默认构造，就需要显示调用某个带参的构造）
• C++11支持在成员变量声明的位置给缺省值，这个缺省值主要是给没有显示在初始化列表初始化的成员使用的。
• 尽量使用初始化列表初始化，因为那些你不在初始化列表初始化的成员也会走初始化列表，如果这个成员在声明位置给了缺省值，初始化列表会用这个缺省值初始化。如果你没有给缺省值，对于没有显示在初始化列表初始化的内置类型成员是否初始化取决于编译器，C++并没有规定。对于没有显示在初始化列表初始化的自定义类型成员会调用这个成员类型的默认构造函数，如果没有默认构造会编译错误。
• 初始化列表中按照成员变量在类中声明顺序进行初始化，跟成员在初始化列表出现的的先后顺序无关。建议声明顺序和初始化列表顺序保持一致。

class Time
{
public:
	Time(int hour)
		: _hour(hour)
	{
		cout << "Time()" << endl;
	}
private:
	int _hour;
};
class Date
{
public:
	Date(int& x, int year = 1, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
		, _t(12)
		, _ref(x)
		, _n(1)
	{
	}
	void Print() const
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
	Time _t; // 没有默认构造
	int& _ref; // 引用
	const int _n; // const
};

12. 类型转换

• C++ 支持内置类型隐式类型转换为类类型对象，需要有相关内置类型为参数的构造函数
• 构造函数前面加 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 };
	return 0;
}

13. static 成员

• 用 static 修饰的成员变量，称之为静态成员变量，静态成员变量一定要在类外进行初始化。
• 静态成员变量为所有类对象所共享，不属于某个具体的对象，不存在对象中，存放在静态区。
• 用 static 修饰的成员函数，称之为静态成员函数，静态成员函数没有this指针。
• 静态成员函数中可以访问其他的静态成员，但是不能访问非静态的，因为没有 this 指针。
• 非静态的成员函数，可以访问任意的静态成员变量和静态成员函数。
• 突破类域就可以访问静态成员，可以通过类名 :: 静态成员或者对象.静态成员来访问静态成员变量和静态成员函数。
• 静态成员也是类的成员，受 public、protected、private 访问限定符的限制。
• 静态成员变量不能在声明位置给缺省值初始化，因为缺省值是个构造函数初始化列表的，静态成员变量不属于某个对象，不走构造函数初始化列表。

静态成员变量通常在 计数器、单例模式的使用等中使用，暂时还不怎么能遇到。

14. 友元

• 友元提供了一种突破类访问限定符封装的方式，友元分为：友元函数和友元类，在函数声明或者类声明的前面加friend，并且把友元声明放到一个类的里面。
• 外部友元函数可访问类的私有和保护成员，友元函数仅仅是一种声明，他不是类的成员函数。
• 友元函数可以在类定义的任何地方声明，不受类访问限定符限制。
• 一个函数可以是多个类的友元函数。
• 友元类中的成员函数都可以是另一个类的友元函数，都可以访问另一个类中的私有和保护成员。
• 友元类的关系是单向的，不具有交换性，比如A类是B类的友元，但是B类不是A类的友元。
• 友元类关系不能传递，如果A是B的友元，B是C的友元，但是A不是B的友元。
• 有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。

前面在实现 <<和>> 的运算符重载的时候，就用到了友元，其实那只是我偷懒没用 getter 和 setter 实现，使用友元会破坏封装，所以还是尽量使用 getter 和 setter 的写法。

15. 内部类

• 如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，跟定义在全局相比，他只是受外部类类域限制和访问限定符限制，所以外部类定义的对象中不包含内部类。
• 内部类默认是外部类的友元类。
• 内部类本质也是一种封装，当A类跟B类紧密关联，A类实现出来主要就是给B类使用，那么可以考虑把A类设计为B的内部类，如果放到 private/protected 位置，那么A类就是B类的专属内部类，其他地方都用不了。

16. 匿名对象

• 用类型(实参)定义出来的对象叫做匿名对象，相比之前我们定义的类型对象名（实参)定义出来的叫有名对象
• 匿名对象生命周期只在当前一行，一般临时定义一个对象当前用一下即可，就可以定义匿名对象。