4. 函数重载
函数重载就是同一个函数名可以重复被定义，即允许定义相同函数名的函数。但是相同名字的函数怎么在使用的时候进行区分呢？所以同一个函数名的函数之间肯定是要存在不同点的，除了函数名外，还有返回类型和参数两部分可以视为函数的特征。
以返回类型来区别，因为在函数调用时不能显式地指出函数返回类型，所以难以使用返回类型来区别。因此只剩下了参数来区分，我们可以总结出以下三种常见的函数重载的情况：
①参数个数不相同：
void func(int a, int b)
{
cout << a << b << endl;
}
void func(int a)
{
cout << a << endl;
}
int main()
{
func(1, 2);
func(1);
return 0;
}②参数类型不同：
void func(int a, char b)
{
cout << a << b << endl;
}
void func(int a, int b)
{
cout << a << b << endl;
}
int main()
{
func(1, 'a');
func(1, 2);
return 0;
}
③参数类型顺序不同：
void func(int a, char b)
{
cout << a << b << endl;
}
void func(char b, int a)
{
cout << b << a << endl;
}
int main()
{
func(1, 'a');
func('a', 1);
return 0;
}
我们不禁发问，为什么C++支持函数重载，而C语言不支持呢？我以Visual Studio 2022为例，不同编译器的规定方式不同。我们通过观察链接报错，发现C语言中外部符号仅仅是函数名，这就意味着函数在C语言编译中的符号就是函数名，那么相同函数名肯定会产生冲突。
C++就不一样了，可以发现C++给函数赋予的符号要更加复杂。通过观察规律，我们会发现C++在处理时加入了参数类型（H表示int，D表示char）。因此虽然函数名相同，但是参数不同，编译器依然可以顺利区分，达到函数重载的功能。
5. 引用
5.1 引用简介
引用是C++相较于C语言创新的地方。引用可以理解为替一个已经存在的变量起一个别名，这就意味着引用一旦定义，那么可以认为引用变量就是原变量，它们是同一个东西。因此定义引用变量时不开辟空间，引用变量和原变量使用同一块空间。
int main()
{
int a = 1;
int& ra = a; //定义引用变量
cout << a << ' ' << ra << endl;
a++;
cout << a << ' ' << ra << endl;
ra++;
cout << a << ' ' << ra << endl;
return 0;
}定义引用类型的时候，必须和引用实体是同种类型的。
5.2 引用的特性
①引用在定义时必须初始化。之所以这么规定与第三条特定有关，因为一旦创建了引用就无法再改变其引用的实体了，所以如果不进行初始化，那就无法再和需要的引用实体进行关联了。即引用变量和引用实体的配对一定发生且只发生在初始化时。
int main()
{
//int& ra; //error 没有初始化
int b;
int& rb = b;
return 0;
}②一个变量可以存在多个引用。
int main()
{
int a = 1;
int& ra = a;
int& rra = a;
return 0;
}③引用一旦引用一个实体，再不能引用其他实体。这句话就是引用实体不可以发生改变，这是因为会产生歧义。
int main()
{
int a = 3;
int b = 8;
int& ra = a;
ra = b;//歧义：①将b的值赋值给ra；②将b作为引用变量ra的实体
return 0;
}5.3 常引用
常引用顾名思义，就是对一个常量的引用，使用const进行修饰限制。值得注意的是，常引用的引用实体并非都是常量，而是一些具有常量性质的值（字面量、常量、常变量、临时变量等）。常引用自从初始化后便不会再改变，换言之不可以通过赋值等手段修改常引用的值（此时的常引用就可以被视为一个常量）。
需要格外强调的两点：
①定义引用时，权限可以缩小：非常量值作为常引用的引用实体；权限不可以放大：常量值作为非常量引用的引用实体。
②在之前的非常量引用定义时类型不同，不可以初始化的原因是发生了隐式类型转换，使得实际上是将具有常性的临时变量赋给非常量引用，因此错误原因在于权限放大。根据这一点我们就可以知道，常引用尽管类型不同，但是因为隐式类型转换所以依旧可以正常定义。
int main()
{
const int a = 10;
//int& ra = a; //error
const int& ra = a; //correct
//int& rb = 10; //error
const int& rb = 10; //correct
double d = 3.14;
//int& rd = d; //error
const int& rd = d; //correct,rd==3 d首先隐式类型转换为int，产生一个临时变量，临时变量具有常性所以可以赋给常引用
d = 4.48;
cout << d << ' ' << rd << endl; //4.48 3
return 0;
}5.4 函数指针的引用
函数指针的引用注意点在代码注释中给出。
void func(int a)
{
cout << a << endl;
}
typedef void(**fpp)(int);
typedef void(*fp)(int);
typedef void(f)(int);
int main()
{
//对于定义函数指针引用：
//1.注意定义的引用的类型和引用实体的类型相同。
// ①函数名有两种解释方式，函数名具有右值属性。以func为例：void(*)(int)和void()(int)
// ②注意辨别不同级函数指针。
void(*pf)(int) = func;
void(**ppf)(int) = &pf;
//2.注意区别左值右值，左值只能使用非常量引用，右值只能使用常量引用
// 区分左右值的方式：判断能否位于赋值符号左边。如*p可以就是左值，&func不可以就是右值
// 注意：函数名是右值，所以在定义类似于void()(int)类型的引用（不是指针的函数类型）时,一定是常量引用
//3.注意定义函数指针的引用可以存在两种方式：①使用typedef；②不使用typedef。
/*f func_;
f& rfunc_ = func;
rfunc_ = func;*/ //void()(int)类型的引用一定是常量引用
//非常量引用的定义方式
//1.使用typedef
fp& r2 = pf;
//r2 = func;
fpp& r3 = ppf;
//r3 = &r2;
//2.不使用typedef
void(*&rr2)(int) = pf;
//rr2 = func;
void(**&rr3)(int) = ppf;
//rr3 = &rr2;
//常量引用的定义方式
//f& r1 = func;
//void(&rr1)(int) = func;
//以上两种方式虽然可行不报错，但是体现不出常引用，所以不建议使用
//r1 = func;
//rr1 = func;
//1.使用typedef
const f& r1_c = func;
//r1_c = func;
const fp& r2_c = pf;
//r2_c = func;
const fpp& r3_c = ppf;
//r3_c = &r2;
//2.不使用typedef
void(const &rr1_c)(int) = func;
//rr1_c = func;
void(*const &rr2_c)(int) = pf;
//rr2_c = pf;
void(**const &rr3_c)(int) = ppf;
//rr3_c = ppf;
const fp& r_a = func;
const fp& r_b = &func;
void(* const& r_c)(int) = func;
void(* const& r_d)(int) = &func;
// 因为函数名有两种解释方式，所以上述的定义方式也是正确的
void(*&r_e)(int) = *ppf;
//void(*&r_e)(int) = &func;
//void(*&r_e)(int) = func;
//因为*ppf是左值，所以没有问题；而&func和func是右值，所以会报错
return 0;
}5.5 引用的应用
5.5.1 传递参数（输出型参数）
C语言中输出型参数采取传指针的方式，C++中可以使用引用来传递，效果相同但是代码更加简洁。
void swap(int& a, int& b)
{
int tmp = a;
a = b;
b = tmp;
}
int main()
{
int x = 1;
int y = 2;
swap(x, y);
cout << x << ' ' << y << endl;
return 0;
}5.5.2 传递参数（大空间对象传参，减少拷贝）
在传递如结构体等大空间对象时为了减少拷贝提高效率，可以使用引用来传参。
struct Node
{
struct Node* next;
int val;
};
void func(struct Node& node)
{}
int main()
{
struct Node n1;
func(n1);
}5.5.3 做返回值
这里给出一个引用做返回值的正确例子。我们在下文详细分析引用作返回值的特性。
int& Add(int a,int b)
{
//static int x = a + b; //这样写因为static只定义一次，所以会导致再次调用函数时不会执行这一步。
static int x;
x = a + b;
return x;
}
int main()
{
int& a = Add(2,4);
cout << a << endl;
a = Add(8, 9);
cout << a << endl;
return 0;
}那么让引用成为返回值有什么好处与注意事项呢？我们对比着返回值的情况来分析。
① 返回引用可以省去拷贝，返回时内存中不产生副本。值返回首先将值交给寄存器，然后释放栈帧，再然后将寄存器的值mov到需要的位置。在此期间就存在拷贝副本的产生，相当于寄存器充当了临时变量的作用。引用返回则是直接返回变量，省去了中间变量的拷贝开销。如果是使用变量接收则相当于拷贝赋值，如果使用引用接收则是相当于定义引用。所以引用返回值效率更高。
②注意引用返回的变量不可以是局部非静态变量，因为局部非静态变量在栈帧中，当函数结束栈帧释放后，返回值就变得不可控了。
int cal1(int a)
{
int b = a * 2;
return b;
}
int& cal2(int a)
{
static int b;
b = a * 2;
return b;
}
int main()
{
int num1 = cal1(1); //case1：返回方式：返回值。
//在栈中开辟空间的b在函数结束后，将值交给临时变量（寄存器），再由临时变量交给num1，内存中产生了返回值的副本（临时变量）
//int& num2 = cal1(2); //case2：报错，因为函数返回的值是临时变量，具有常性
int num3 = cal2(3); //case3：返回方式：返回引用。
//在函数结束后，因为是返回引用，所以实际上是返回b变量的别名。而num3的值则是直接从b变量处拷贝而来，避免了副本的产生。
//因为b变量是一个静态变量，所以不会随着栈帧被释放，才能在栈帧释放后进行拷贝。
int& num4 = cal2(4); //case4：返回方式：返回引用。
//在函数结束后，返回了b变量且不产生副本，而引用声明num4使用返回值初始化，所以num4就成为了b变量的引用、别名。
//因为b变量是一个静态变量，所以不会随着栈帧被释放，所以引用依旧有效。
}5.6 引用和指针
①引用相当于是一个别名不占空间。但在底层实现上各个编译器有所不同，一般情况下，引用实际上就是一个指针实现的。所以在实际来说引用还是占空间的。
②在我看来引用是指针的更简单的表达形式。引用变量实际就是指向引用实体的指针，而使用引用变量时默认会进行解引用。
③没有空引用与多级引用但是有空指针和多级指针。
④引用必须初始化并且不可以改变引用实体。指针则可以不受这些限制。
通过以上叙述发现引用虽然是指针的简练表达，但是仅仅限于某些特定情况下。指针还是通用的方法，所以引用只能是极大简化指针的使用，但是无法代替指针。
