函数重载与引用

一、函数重载

函数重载：是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数 或 类型 或

类型顺序)不同，常用来处理实现功能类似数据类型不同的问题。

对于c语言是不允许重名函数的存在的，当函数名字相同时，就会报错。但是对于 c++ 可以。

因为C语言是根据函数名来去找函数的，可以简单的理解为C语言函数名就是地址

1. 重载规则

当函数重载条件满足如下三条时，则可以构成函数重载：

1.参数类型不同

2.参数个数不同

3.参数类型顺序不同

4、仅仅返回类型不同不足以称为函数重载的重载

5、需要在同一作用域下

2.重载列子

int add(int a, int b)
{
	return a + b;
}

void add(int a, float b)
{
	cout << "add(int a,float b)" << endl;
}

void add(float a, int b)
{
	cout << "add(float a,int b)" << endl;
}

float add(float a, float b)
{
	return a + b;
}

3.函数名修饰规则

对于函数重载后的函数，执行会不会变慢？不会，因为不是在运行时匹配，而是在编译时。

编译时如何进行识别？

对于C语言来说，就是依靠函数名去找函数的，如果函数名相同，则会冲突，因为不知道找哪个

对于C++来说，是通过函数名+参数类型+参数个数+参数顺序

二、引用

1. 引用的基本概念

   • 引用是一个别名：引用是一个已存在变量的别名，通过引用可以访问原始变量的值。
   • 引用必须初始化：引用在创建时必须进行初始化，并且一旦初始化后，它将一直引用同一个变量。

2. 使用引用的好处

   • 传递函数参数：通过引用传递参数，可以避免产生额外的复制开销，并且可以直接修改原始变量的值。
   • 返回函数结果：函数可以返回引用类型，以便返回引用指向的变量，而不是复制一个新的副本。
   • 在容器中使用引用：在使用STL容器时，使用引用可以避免元素的拷贝，提高效率。

3. 引用与指针的比较

   • 引用与指针类似，但有一些关键区别。引用是一个别名，而指针是一个变量，可以指向其他变量。
   • 引用不能为空：引用在创建时必须进行初始化，并且不能重新赋值为空。
   • 引用使用更方便：相比指针，引用语法更简洁明了，更容易理解和使用。

4. 常量引用

   • 常量引用是指对常量进行引用，即引用的变量不能被修改。
   • 常量引用可以绑定到临时对象，以便在函数调用中传递临时对象的值。

5. 引用作为返回类型

   • 函数可以返回引用类型，在函数外部直接修改原始变量的值。
   • 注意返回局部变量的引用可能导致悬空引用，应避免这种情况。

1.本质

我们发现a和b不仅值相等，连地址也是相同的。而这就说明，b 就是 a ，在语法层面上，这里 b 并不是开辟的新空间，而是对原来的 a 取了一个新名称，叫做 b

相当于一块空间有多个名字一样，都是指向这块空间的

而如果这时候对 a 或 b 任意一个修改，那么 a 和 b 都会发生修改。

2.特性

1. 引用必须在定义时初始化

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

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

int main()
{
	int a = 10;
	int& b = a;

	int c = 20;
	b = c;

	return 0;
}

那么这样又是什么意思呢

b引用了a，然后b=c是将c的值赋值给b
这就说明引用一旦引用一个实体，就不能引用其他实体，引用是不会发生改变的

3.引用例子

引用作为函数返回值
在Test函数当中定义了一个n，然后返回n的别名
在main函数当中用ret接受n的值
再打印ret，结果一直都是1

虽然Test（）那块函数栈帧已经被销毁，但是我们使用int ret接受的n的值，并不是n
所以ret就是1

#include

using namespace std;
int& Test()
{
	int n = 1;
	return n;
}
int main()
{
	int ret = Test();
	cout << ret << endl;
	cout << ret << endl;
	cout << ret << endl;
	cout << ret << endl;
	return 0;
}

然后我们将ret换为int & 来接受
这时候ret就是n的别名

n出了函数作用域就销毁了，函数栈帧销毁了，但是里面的东西还没有被覆盖，传引用返回给ret的话，ret话会去访问原来n那块空间的值
函数调用先传参，所以调用cout的时候，ret先去访问n原来的那块空间，得到n值之后再给cout
cout函数会建立一块函数栈帧空间在原来的Count上，所以打印出1
第二次调用cout的时候，ret再去访问n的时候，原来的空间已经被破坏了，所以这一次打印出来的是随机值

#include

using namespace std;
int& Test()
{

	int n = 1;
	return n;
}
int main()
{

	int& ret = Test();
	cout << ret << endl;
	cout << ret << endl;
	cout << ret << endl;
	cout << ret << endl;
	return 0;
}

所以说如果用引用做返回值的话就需要确保返回的东西除了作用域是还存在的

4.引用的权限

#include
using namespace std;
int main()
{
	int a = 1;
	int& b = a;
	const double& d = a;
	const int& c = 1;

	return 0;
}

对于类型转换，会先产生一个临时变量
然后临时变量具有常性，所以不可以被修改
所以double &d=a; 实际上并不是d去引用a
而是d去引用一个临时变量，所以需要＋const去修饰

5.效率比较

#include 
struct A { int a[10000]; };
A a;
// 值返回
A TestFunc1() { return a; } // 拷贝
// 引用返回
A& TestFunc2() { return a; } // 不拷贝
void TestReturnByRefOrValue()
{
	// 以值作为函数的返回值类型
	size_t begin1 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc1();
	size_t end1 = clock();
	// 以引用作为函数的返回值类型
	size_t begin2 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc2();
	size_t end2 = clock();
	// 计算两个函数运算完成之后的时间
	cout << "TestFunc1 time:" << end1 - begin1 << endl;
	cout << "TestFunc2 time:" << end2 - begin2 << endl;
}

int main()
{
	TestReturnByRefOrValue();

	return 0;
}

由于传值返回要拷贝，所以当拷贝量大，次数多时，比较耗费时间；而传引用返回就不会，因为返回的就是别名

6.指针跟引用的区别

1. 定义和初始化：

   • 指针：需要使用*来声明，可以指向不同的对象。
   • 引用：使用&来声明，必须在初始化时绑定到一个已存在的变量。

2. 空值（Null）：

   • 指针：可以具有空值（null），表示未指向有效的内存地址。
   • 引用：不存在空引用的概念，必须绑定到一个已存在的变量。

3. 变量绑定：

   • 指针：可以在声明后重新指向其他变量。
   • 引用：在声明时就必须绑定到一个变量，并且无法改变绑定对象。

4. 空间占用：

   • 指针：占用额外的内存空间，通常是4或8个字节。
   • 引用：不占用额外的内存空间，只是变量的别名。

5. 空间操作：

   • 指针：可以进行算术运算和通过解引用操作符*访问所指的内存地址的值。
   • 引用：不能进行算术运算，直接访问绑定变量的值。

6. 空间限制和安全性：

   • 指针：可以指向任意类型的对象，但需要注意空指针异常和野指针的问题。
   • 引用：只能用于已存在的变量，更加简洁和安全。

int main()
{
	int a = 10;
	
	int& ra = a;
	ra = 20;

	int* pa = &a;
	*pa = 20;
	return 0;
}