hello，各位小伙伴，本篇文章跟大家一起学习C++：函数重载和引用，感谢大家对我上一篇的支持，如有什么问题，还请多多指教 ！
文章目录
- 函数重载
- 1.函数重载的概念
- 为什么C++支持函数重载
- 引用
- 引用的概念
- 引用特性
- 引用的使用场景
- 1.做参数
- 2.做返回值
- 传值、传引用效率比较
- 引用和指针的区别
函数重载
1.函数重载的概念
函数重载：是函数的一种特殊情况，C++允许在
同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数 或 类型 或 类型顺序)不同，常用来处理实现功能类似数据类型不同的问题。
要注意是同一作用域，不同作用域可以同名，但是不属于函数重载
1.参数个数不同：
void f(int a)
{
printf("%d\n",a);
}
void f(int a,int b)
{
printf("%d %d\n",a,b);
}
2.参数类型不同：
void f(int a,int b)
{
printf("%d %d\n",a,b);
}
void f(double a,double b)
{
printf("%lf %lf\n",a,b);
}
3.参数类型顺序不同：
void f(int a，char b)
{
printf("%d %c\n",a,b);
}
void f(char b,int a)
{
printf("%d %c\n",a,b);
}
在函数重载时要注意可能会发生分歧，例如：
#include<iostream>
using namespace std;
void f(int a)
{
cout<<a<<endl;
}
void f(char a)
{
cout<<a<<endl;
}
int main()
{
int a = 1;
f(a);
return 0;
}
上述代码会报错，因为编译器不知道要调用哪一个f()函数，在传参时a可以隐式转换为char类型，这样就发生了分歧。
为什么C++支持函数重载
在C/C++中，一个程序要运行起来，需要经历以下几个阶段：预处理、编译、汇编、链接。
举个例子，a.cpp调用b.cpp中的Add()函数，那么链接器看到a.o调用Add()函数，但没有地址时，就会在去b.o寻找Add()的地址，然后链接在一起。
a.o、b.o分别为a.cpp、b.cpp预处理、编译、汇编后得到的文件
那么链接器怎么去找呢？
C++会使用已经修饰过的了Add()函数去寻找，怎么修饰与编译器有关，而C语言会直接使用Add这个函数名去寻找，那么两个一模一样的函数名，自然会发生分歧，使得编译器不知道走哪一个。
总的来说：C++在链接时，会使用已经修饰过的函数名去寻找地址，函数参数个数不同、参数类型不同、参数类型顺序不同，修饰后的函数名自然不同，从而不会发生分歧。
！！！知道了为什么支持函数重载后，还有一点细节：返回值不同，构成函数重载吗？
答案是：不支持
如果两个函数函数名和参数是一样的，返回值不同是
不构成重载的，因为调用时编译器没办
法区分。
引用
引用的概念
引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。
举个例子：陈明的别名是小明，但是小明就是陈明，指的是同一个人。
使用：类型& 引用变量名(对象名) = 引用实体；
例子：
int main()
{
int a = 1;
int& b = a;
// int & b = a;
//（引用类型） & （引用变量） = （引用实体）
b = 3;
cout<<a<<endl;
printf("%p\n",&a);//表达式1
printf("%p\n",&b);//表达式2
return 0;
}
猜猜a的值为多少？没错，答案是3。
前面讲到，它和它引用的变量共用同一块内存空间，所以b指的就是a，b的值改变，那么a当然会变，所以表达式1和表达式2打印的结果一样，都是同一个地址。
注意：引用类型必须和引用实体是同种类型的
相信小伙伴们就能很容易理解，那么细节来了：
int main()
{
const int a = 1;
int& b = a;
return 0;
}
这么些是否正确呢？相信聪明的小伙伴们一眼就看出答案：这么些是错误的。
const修饰a，那么a是不能改变的，而b并没有const修饰，所以b可以改变，也就是权限被放大了，本来a自身都不能改变，凭什么b可以。
再来：
int main()
{
int a = 1;
const int& b = a;
return 0;
}
这么写b不能改变，a可以，权限被缩小，是可以的。
继续：
int main()
{
int a = 1;
const int* pa = &a;
int*& b = pa;
return 0;
}
很明显，这么写是错的，权限被放大了。
那么这个：
int main()
{
int a = 1;
int* const pa = &a;
int*& b = pa;
return 0;
}
这么写是正确的。
这两个声明之间存在重要的区别，这涉及到C++中指针和const关键字的使用。
-
int* const pa = &a;：- 这里
pa是一个指针，它指向一个整数（int*）。 - 关键字
const出现在*前面，表示指针本身是常量，即指针一旦指向了某个地址之后，就不能再指向其他地址。 - 也就是说，
pa是一个常量指针，它的值（即指向的地址）不可以被改变，但是它所指向的值可以被修改。
- 这里
-
const int* pa = &a;：- 这里
pa是一个指向常量整数的指针。 - 关键字
const出现在int前面，表示指针所指向的值是常量，即不能通过pa修改所指向的值。 - 也就是说，
pa是一个指针，它可以指向任意整数，但通过pa只能读取所指向的值，而不能修改。
- 这里
总结来说，int* const pa = &a; 表示 pa 是一个指针常量，而 const int* pa = &a; 表示 pa 是一个指向常量整数的指针。
引用特性
- 引用在
定义时必须初始化(你总不能想到一个别名先放着，看到谁就给谁用吧)
int& a;//这么些是错的
- 一个变量可以有多个引用
int a = 1;
int& b = a;
int& c = a;
int& d = a;
- 引用一旦引用一个实体，再不能引用其他实体
int a = 1;
int& b = a;
int c = 1;
b = c;//这么些是错的
引用的使用场景
1.做参数
void Swap(int& left, int& right)
{
int temp = left;
left = right;
right = temp;
}
int main()
{
int a = 1;
int b = 2;
int& c = a;
int& d = b;
Swap(c,d);
return 0;
}
2.做返回值
int& Test1()
{
int n = 0;
n++;
return n;
}
int main()
{
int a = 0;
int& b = a;
b = Test1();
cout << a;
return 0;
}
传值、传引用效率比较
我们知道：
以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。
所以，传引用的效率比传值的效率更高，引用作为返回值比值作为返回值效率更高。
引用和指针的区别
在语法概念上，引用是没有独立空间的，他就是引用实体的另一个名字，和其引用实体共用同一块空间。
int main()
{
int a = 10;
int& ra = a;
cout<<"&a = "<<&a<<endl;
cout<<"&ra = "<<&ra<<endl;
return 0;
}
在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。
int main()
{
int a = 10;
int& ra = a;
ra = 20;
int* pa = &a;
*pa = 20;
return 0;
}
我们来看其汇编代码对比指针和引用
可以看出操作上是一样的。
引用和指针的不同点:
- 引用概念上定义一个变量的别名，指针存储一个变量地址。
- 引用在定义时必须
初始化，指针没有要求 - 引用在初始化时引用一个实体后，就
不能再引用其他实体，而指针可以在任何时候指向任何
一个同类型实体 没有NULL引用，但有NULL指针- 在sizeof中含义不同：引用结果为
引用类型的大小，但指针始终是地址空间所占字节个数(32
位平台下占4个字节) - 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
- 有多级指针，但是
没有多级引用 - 访问实体方式不同，
指针需要显式解引用，引用编译器自己处理 引用比指针使用起来相对更安全
好啦，这篇文章就到此结束了
所以你学会了吗？
好啦，本章对于C++：函数重载和引用的学习就先到这里，如果有什么问题，还请指教指教，希望本篇文章能够对你有所帮助，我们下一篇见！！！
如你喜欢，点点赞就是对我的支持，感谢感谢！！！
