C++入门：函数重载与引用

Crazy_Rabbits239

已于 2024-02-28 21:27:30 修改

阅读量657

点赞数 12

分类专栏： C/C++ 文章标签： c++ 开发语言

于 2024-02-27 21:38:28 首次发布

本文链接：https://blog.csdn.net/Crazy_Rabbits/article/details/136329017

版权

C/C++ 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

一、函数重载

在C语言中，我们可能需要使用具有相同功能的函数，例如Add函数，但是由于函数不能重复定义，我们不得不改头换面，在名字加上一些其他的符号，以完成同一功能。

但是在C++中，函数重载能帮我们解决这个问题。下面以Add函数为例来讲述函数重载：

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
int Add(int a, int b)
{
	return a + b;
}
double Add(double a, double b)
{
	return a + b;
}
int main()
{
	cout << Add(3, 5) << endl;
	cout << Add(2.0, 7.0) << endl;
	return 0;
}

这个函数能成功运行，离不开编译器的功劳，编译器会帮你区分变量的类型，以来给你调用合适的函数。

1.两个“无法”

无法重载仅按返回类型区分的函数

//Error
int Add(int a, int b)
{
	return a + b;
}
double Add(int a, int b)
{
	return a + b;
}

无法重载仅改变形参类型位置的函数（涉及到了类型转换的）

//Error
int Add(int a, double b)
{
	return a + b;
}
double Add(double a, int b)
{
	return a + b;
}

2.三个“可以”

可以重载参数类型不同的函数

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
//函数重载
int Add(int a, int b)
{
	return a + b;
}
double Add(double a, double b)
{
	return a + b;
}
int main()
{
	cout << Add(3, 5) << endl;
	cout << Add(2.5, 7.5) << endl;
	return 0;
}

可以重载参数数量不同的函数

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
void Print(int a)
{
	cout << "OK" << endl;
}
void Print(int a, int b)
{
	cout << "OK" << endl;
}
int main()
{
	Print(1);
	Print(1, 2);
	return 0;
}

可以重载参数类型位置不同的函数（不涉及到类型转换）

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
void Fun(int a, char b)
{
	cout << "int a,char b" << endl;
}
void Fun(char a, int b)
{
	cout << "char a,int b" << endl;

}
int main()
{
	Fun(1, 'a');
	Fun('a', 1);
	return 0;
}

3.C++支持函数重载的原理——名字修饰

了解即可，感兴趣的读者可以去搜索一下。在Windows下VS编译器对函数名字的修饰规则相对复杂难懂，可以Linux下使用g++在编译中使用反汇编看看。这里就不介绍了。

二、引用

引用，可以理解为给变量取别名，编译器不会为引用变量开辟新的空间，它和它引用的变量共用一块空间。

举个更形象的例子，小明被张三称为“明兄”，被李四称为“明弟”，但是这两个称呼都指向的是小明这个人，而不是张明，李明，其他什么明。前面用了指向这个字，结合等一下要讲的作用，可以知道引用与指针具有相似的作用。

1.定义引用

#include<iostream>
using namespace std;
int main()
{
	int a = 3;
    //定义引用，只需要在类型后面加&就行了
	int& b = a;
    //引用是可以多重引用的，c是b的别名，b是a的别名，那么c是a的别名
	int& c = b;
	cout << a << " " << b << " " << c << " " << endl;
	return 0;
}

诶，如果我定义一个新变量，给它赋值，不也能达成效果吗？但是这浪费了内存空间，说到内存空间，那我们来观察一下叭。

可以看到，a、b、c三个变量的地址是相同的，更加说明了引用是不会开辟新的空间的。

公式：

类型& 引用变量名（对象名） = 引用实体;

2.引用的特性

同一个变量允许存在多个引用
引用在定义时必须初始化，即决定成为谁的别名
引用一旦有了一个实体，就不能再中途更改，做其他变量的引用
求引用的地址，就是求实体的地址

3.常引用

#include<iostream>
using namespace std;
int main()
{
	//表达式必须是可以修改的左值：因为const修饰了别名b，导致我们无法通过b来修改a,但是我们可以直接修改a来修改b
	int a = 10;
	const int& b = a;
	b = 3;
	a = 3;

    //将"int&"类型的引用绑定到"const int"类型的初始值设定项时，限定符被丢弃and无法从"const int"转换为"int &"
    //但是可以通过更改引用的类型来进行绑定
    const int c = 10;
    int& d = c;
    const int& e = c;
	return 0;
}

4.使用场景

（1）.做函数参数

void swap(int& a, int& b)
{
	int temp = a;
	a = b;
	b = temp;
}

当引用做函数参数时会直接对原数据进行操作，即可能会更改原数据。

（2）.做返回值

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

下面请思考一串代码，想想这串代码会输出什么内容，又是为什么会这样。

//x86的环境下运行
#include<iostream>
using namespace std;
int& add(int a, int b)
{
	int c = a + b;
	return c;
}
int main()
{
	int& ret = add(1, 2);
	add(3, 4);
	cout << "add(1,2) is " << ret << endl;
	return 0;
}

这是由于函数返回了局部变量c的别名，而c在销毁后再一次获得了原先的地址，导致再一次调用函数是又一次使用了该地址，对引用的实体进行修改，能影响到引用，所以ret的值也就改变了。

#include<iostream>
using namespace std;
int& add(int a, int b)
{
	int c = a + b;
	return c;
}
int main()
{
	int& ret = add(1, 2);
	add(3, 4);
	cout << "haha" << endl;
	cout << "add(1,2) is " << ret << endl;
	return 0;
}

但是当你这样修改之后，打印的结果就会更改了。这一块涉及到了函数栈桢的内容，就不过多讲解了。