C++：函数重载和引用

hello，各位小伙伴，本篇文章跟大家一起学习C++：函数重载和引用，感谢大家对我上一篇的支持，如有什么问题，还请多多指教 ！

函数重载

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关键字的使用。

1. int* const pa = &a;：

   • 这里 pa 是一个指针，它指向一个整数（int*）。
   • 关键字 const 出现在 * 前面，表示指针本身是常量，即指针一旦指向了某个地址之后，就不能再指向其他地址。
   • 也就是说，pa 是一个常量指针，它的值（即指向的地址）不可以被改变，但是它所指向的值可以被修改。

2. const int* pa = &a;：

   • 这里 pa 是一个指向常量整数的指针。
   • 关键字 const 出现在 int 前面，表示指针所指向的值是常量，即不能通过 pa 修改所指向的值。
   • 也就是说，pa 是一个指针，它可以指向任意整数，但通过 pa 只能读取所指向的值，而不能修改。

总结来说，int* const pa = &a; 表示 pa 是一个指针常量，而 const int* pa = &a; 表示 pa 是一个指向常量整数的指针。

引用特性

1. 引用在定义时必须初始化(你总不能想到一个别名先放着，看到谁就给谁用吧)

int& a;//这么些是错的

2. 一个变量可以有多个引用

int a = 1;
int& b = a;
int& c = a;
int& d = a;

3. 引用一旦引用一个实体，再不能引用其他实体

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;
}

我们来看其汇编代码对比指针和引用

可以看出操作上是一样的。

引用和指针的不同点:

1. 引用概念上定义一个变量的别名，指针存储一个变量地址。
2. 引用在定义时必须初始化，指针没有要求
3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何
   一个同类型实体
4. 没有NULL引用，但有NULL指针
5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32
   位平台下占4个字节)
6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
7. 有多级指针，但是没有多级引用
8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
9. 引用比指针使用起来相对更安全

好啦，这篇文章就到此结束了
所以你学会了吗？

好啦，本章对于C++：函数重载和引用的学习就先到这里，如果有什么问题，还请指教指教，希望本篇文章能够对你有所帮助，我们下一篇见！！！

如你喜欢，点点赞就是对我的支持，感谢感谢！！！