函数重载

函数重载的概念

在自然语言中，相同的一个词可能有多重含义，人们可以通过上下文来判断这个词的具体意思，在C++中也存在这种现象，这种现象叫做函数重载。

函数重载的概念：是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数 或 类型 或 类型顺序)不同，常用来处理实现功能类似数据类型不同的问题。

函数重载分为三种：1.参数个数不同 2.参数的类型不同 3.参数顺序不同
具体示例：
第一种：参数了，类型不同

int Add(int left, int right)
{
	 cout << "int Add(int left, int right)" << endl;
	 return left + right;
}
double Add(double left, double right)
{
	 cout << "double Add(double left, double right)" << endl;
	 return left + right;
}

第二种：参数的个数不同

// 2、参数个数不同
void f()
{
	 cout << "f()" << endl;
}
void f(int a)

第三种：参数的顺序不同

// 3、参数类型顺序不同
void f(int a, char b)
{
	 cout << "f(int a,char b)" << endl;
}
void f(char b, int a)
{
	 cout << "f(char b, int a)" << endl;
}

函数重载的原理----名字的修饰

在编译阶段，编译器会根据函数名以及函数参数的类型和数量生成一个唯一的标识符。这个标识符通常包括函数名以及参数的类型信息，以便在链接阶段能够区分不同的函数。这个过程称为名称修饰。在不同的编程语言和编译器中，名称修饰的规则可能会有所不同。

当程序调用一个重载的函数时，编译器会根据传递给函数的参数类型和数量，选择最匹配的函数。编译器会根据参数的类型信息生成对应的函数调用，然后在可选的重载函数集合中进行匹配。如果找到了最佳匹配，编译器会生成对应的函数调用。

这种静态的选择过程使得函数重载不会增加运行时的开销，因为函数的选择是在编译阶段完成的，生成的代码直接调用了特定版本的函数，而不需要在运行时进行动态的函数分派。

总的来说，函数重载的底层原理涉及到编译器对函数名称的修饰以及静态函数匹配规则，它使得编译器能够在编译阶段确定最佳匹配的函数版本，并生成对应的函数调用代码。
在Linux操作系统中

可以看到每个函数通过函数重载之后，函数名被修饰之后的函数名都不相同，这就是函数重载的原理。

缺省参数

缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参。

void Func(int a = 0)
{
	 cout<<a<<endl;
}
int main()
{
	 Func();     // 没有传参时，使用参数的默认值
	 Func(10);   // 传参时，使用指定的实参
	return 0;
}

上面代码展示的就是缺省参数的一种形式（全缺省）

缺省参数的分类

缺省参数分为：全缺省和半缺省
全缺省

void Func(int a = 10, int b = 20, int c = 30)
 {
     cout<<"a = "<<a<<endl;
     cout<<"b = "<<b<<endl;
     cout<<"c = "<<c<<endl;
 }

半缺省

void Func(int a, int b = 10, int c = 20)
 {
     cout<<"a = "<<a<<endl;
     cout<<"b = "<<b<<endl;
     cout<<"c = "<<c<<endl;
 }

注意:
1.半缺省参数必须从右往左依次给出，不能间隔着给，因为这样会引起歧义，编译器不知道这个参数对应的是哪个参数。
2.缺省参数不能在声明和定义同时定义，因为如果同时定义，但是缺省参数不同会引起歧义，编译器不知道是取定义的缺省参数还是取声明的缺省参数

引用

在现实生活中，每个人应该都有自己的小名或者别名，当别人叫你的小名的时候这也代指你，在C++中也有一种语法叫做引用，也相当于给一个变量取别名。
引用的定义：引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。

void TestRef()
{
    int a = 10;
    int& ra = a;//<====定义引用类型
    printf("%p\n", &a);
    printf("%p\n", &ra);
}

上面代码运行出来的地址都是一样的，可以说明引用相当于就是变量的另一个名字

引用的特征

1. 引用在定义的时候必须初始化
2. 一个变量可以有多个引用
3. 引用一旦引用一个实体就不能引用其他实体了

注意：被const修饰的变量不能直接引用

void TestConstRef()
{
    const int a = 10;
    //int& ra = a;   // 该语句编译时会出错，a为常量
    const int& ra = a;
    // int& b = 10; // 该语句编译时会出错，b为常量
    const int& b = 10;
    double d = 12.34;
    //int& rd = d; // 该语句编译时会出错，类型不同
    const int& rd = d;
}

被const修饰的变量如果直接引用的话，会产生权限放大的问题，所以如果被const修饰的变量可以在引用前面也加一个const修饰这样两个变量的权限相同，才不会报错。

使用场景

1.做参数

void Swap(int& left, int& right)
{
   int temp = left;
   left = right;
   right = temp;
}

2.做返回值

int& Count()
{
   static int n = 0;
   n++;
   // ...
   return n;
}