C++——基础语法（2）：函数重载

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;		//errorconst int& ra = a;	//correct//int& rb = 10;		//errorconst int& rb = 10;	//correctdouble d = 3.14;//int& rd = d;		//errorconst int& rd = d;	//correct,rd==3  d首先隐式类型转换为int，产生一个临时变量，临时变量具有常性所以可以赋给常引用d = 4.48;cout << d << ' ' << rd << endl; //4.48 3return 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.使用typedeffp& r2 = pf;//r2 = func;fpp& r3 = ppf;//r3 = &r2;//2.不使用typedefvoid(*&rr2)(int) = pf;//rr2 = func;void(**&rr3)(int) = ppf;//rr3 = &rr2;//常量引用的定义方式//f& r1 = func;//void(&rr1)(int) = func; //以上两种方式虽然可行不报错，但是体现不出常引用，所以不建议使用//r1 = func;//rr1 = func;//1.使用typedefconst f& r1_c = func;//r1_c = func;const fp& r2_c = pf;//r2_c = func;const fpp& r3_c = ppf;//r3_c = &r2;//2.不使用typedefvoid(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变量是一个静态变量，所以不会随着栈帧被释放，所以引用依旧有效。
}