C++ 入门不迷路：缺省参数、函数重载与引用轻松拿捏

前言：

上一篇博客主要介绍了C++入门部分的发展历程以及命名空间，这一篇文章我们继续介绍C++入门部分的缺省参数，函数重载以及引用的知识，相信大家看完这篇文章一定会有很大的收获！

目录

一、缺省参数

1）缺省参数的调用：

2）全缺省和半缺省：

3）只能在声明中使用缺省参数的情况：

二、函数重载

1）构成函数重载的三种情况：

1.参数类型不同

2.参数个数不同

3.参数类型顺序不同

2)两种特殊情况不能正确使用函数重载

1.无法构成重载：(函数的仅仅只是返回类型不同，无法构成重载)

2.可以构成重载，但是调用时会出现歧义：(缺省的情况)

三、引用

1.引用的概念和定义

2.引用的特性

3.引用的使用

1.交换值，以及顺序表中的应用（引用传参）：

2.交换指针，以及链表中的应用（引用传参）：

3.无法使用引用的情况：

4.传值返回和传引用返回

5.传引用返回在实践中的使用场景：

6.知识点补充：

4.const引用

1.引用和指针的权限放大和缩小问题（放大不行，缩小可以）：

2.const修饰引用传参：

3.涉及类型转换的const引用：

5.指针和引用的关系（面试考点）

一、缺省参数

• 缺省参数是声明或定义函数时为函数的参数指定⼀个缺省值。在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参，缺省参数分为全缺省和半缺省参数。（有些地方把缺省参数也叫默认参数）

• 全缺省就是全部形参给缺省值，半缺省就是部分形参给缺省值。C++规定半缺省参数必须从右往左依次连续缺省，不能间隔跳跃给缺省值。

• 带缺省参数的函数调用，C++规定必须从左到右依次给实参，不能跳跃给实参。

• 函数声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须函数声明给缺省值。

下面来举例说明每一种情况，需要注意的地方在注释：

1）缺省参数的调用：

#include<iostream>
using namespace std;

void func(int a = 0)
{
	cout << a << endl;
}

int main()
{
	int a = 1;
	func();
	func(a);
	return 0;
}

运行结果为：

2）全缺省和半缺省：

#include<iostream>
using namespace std;
//全缺省
void func1(int a = 10, int b = 20, int c = 30)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl << endl;
}
//半缺省
//从右至左依次缺省才可以，中间不能跳跃缺省
//不能出现int a=10,int b=20,int c或int a=10,int b,int c=30等这种情况
void func2(int a, int b = 20, int c = 30)//或者(int a, int b, int c = 30)
{                                        //如果非要a缺省的话，我们可以把a和c的位置换一下,即int c,int b,int a=10
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl << endl;
}

int main()
{
	func1();
	func1(1);
	func1(1, 2);
	func1(1, 2, 3);
	//func1(1, , 3);//这种不行，不能跳跃传参
	//func2();错误！因为func2是半缺省，未缺省的部分必须传参！
	func2(100);
	func2(100, 200);
	func2(100, 200, 300);
	return 0;
}

3）只能在声明中使用缺省参数的情况：

缺省参数在改进数据结构（比如顺序表，栈和队列等等）中也使用的比较多，我们这里以顺序表这个结构的几个接口来看看，中间的实现我会比较省略，详细的结构实现可以去看一下博主之前的博客。

SeqList.h

#pragma once
#include<iostream>
#include<stdlib.h>

typedef struct SeqList
{
	int* arr;
	int size;
	int capacity;
}SL;

void SLInit(SL* pls, int n = 4);
void SLPushBack(SL* pls, int x);
int SLFind(SL* pls, int x, int i = 0);

SeqList.cpp

#include"SeqList.h"

void SLInit(SL* pls,int n)//前面声明给了缺省参数，这里不能再给了
{
	//...pls->arr = (int*)malloc(n * sizeof(int));
	//...空间不够，扩容
}
void SLPushBack(SL* pls, int x)
{
	//...
}
//返回下标
int SLFind(SL* pls, int x, int i)
{
	while (i < pls->size)
	{
		//...
	}
	//...
	return -1;
}

test.cpp

#include"SeqList.h"
using namespace std;
int main()
{
	SL s1;
	SLInit(&s1);
	int n;
	cin >> n;
	SLInit(&s1, n);
	//已经知道n的大小
	//如果没有输入操作这里n就是不知道的，就会使用缺省的n=4

	//为啥要定义这么一个n呢
	//比如我要尾插1000个数据，那么不用这个的话，就要不停的扩容4-8-16-...-1000，会有消耗
	for (int i = 0; i < n; i++)
	{
		SLPushBack(&s1, i);
	}
	//Find
	//原来的find无法实现找顺序表中所有需要找的元素(重复的只会返回第一个)
	//改了之后，通过下述操作可以找到所有的
	//5 4 6 3 4 7 4
	SL s2;
	SLInit(&s2);
	int i = SLFind(&s2, 4);
	while (i != -1)
	{
		int i = SLFind(&s2, 4, i + 1);
	}
	return 0;
}

二、函数重载

C++⽀持在同⼀作用域中出现同名函数，但是要求这些同名函数的形参不同，可以是参数个数不同或者类型不同。这样C++函数调用就表现出了多态行为，使用更灵活。C语言是不支持同⼀作用域中出现同名函数的。

1）构成函数重载的三种情况：

1.参数类型不同

#include<iostream>
using namespace std;

//1.参数类型不同
int add(int a, int b)
{
	cout << "int add(int a, int b)" << endl;
	return a + b;
}
double add(double a, double b)
{
	cout << "double add(double a, double b)" << endl;
	return a + b;
}

int main()
{
	cout << add(1, 2) << '\n';
	cout << add(1.1, 2.2) << '\n';
	//自动识别函数传的参数类型，调用不同的函数；
	return 0;
}

2.参数个数不同

//2.参数个数不同
#include<iostream>
using namespace std;

void func()
{
	cout << "func()" << "\n";
}
void func(int a)
{
	cout << "func(int a)" << "\n";
}
int main()
{
	func();
	func(1);
	return 0;
}

3.参数类型顺序不同

//3.参数类型顺序不同
#include<iostream>
using namespace std;

void func(int a, char b)
{
	cout << "func(int a, char b)" << "\n";
}
void func(char b, int a)
{
	cout << "func(char b, int a)" << "\n";
}
int main()
{
	func(1, 'a');
	func('a', 1);
	return 0;
}

2)两种特殊情况不能正确使用函数重载

1.无法构成重载：(函数的仅仅只是返回类型不同，无法构成重载)

//返回值不同不能作为重载条件，因为调⽤时也⽆法区分
#include<iostream>
using namespace std;
void func()
{
	cout << "func()" << "\n";
}
int func()
{
	cout << "func()" << "\n";
	return -1;
}
int main()
{
	//调用时无法确定调用那个
	func();
	int x = func();
	return 0;
}

2.可以构成重载，但是调用时会出现歧义：(缺省的情况)

// 下⾯两个函数构成重载
// f()但是调⽤时，会报错，存在歧义，编译器不知道调⽤谁
#include<iostream>
using namespace std;

void func()
{
	cout << "func()" << "\n";
}

void func(int a=10)
{
	cout << "func(int a=10)" << "\n";
}

int main()
{
	func(1);//这个可以
	func(); //这样调用就不行了，不确定调用那一个
	return 0;
}

三、引用

1.引用的概念和定义

引用不是新定义一个变量，而是给已存在变量取了一个别名， 编译器不会为引用变量开辟新的内存空间，它和它引用的变量共用同一块内存空间。 比如：水浒传中李逵，宋江叫"铁牛"，江湖上人称"黑旋风"；林冲，外号豹子头；

类型& 引用别名 = 引用对象

比如：int a = 0;

           int& b = a;//这里b就是a的引用（别名）

C++中为了避免引入太多的运算符，会复用C语言的⼀些符号，比如前面的<< 和 >>，这里引用也和取地址还可以是按位与运算符都使用了同一个符号&，大家注意使用方法角度区分就可以。

代码实现引用的概念：

#include<iostream>
using namespace std;

int main()
{
	int a = 0;
	//引用：b和c是a的别名
	int& b = a;
	int& c = a;
	//也可以给别名b取别名，d相当于还是a的别名
	int& d = b;

	++d;//实际上就是++a，a直接改变了
	// 这⾥取地址我们看到是⼀样的
	cout << &a << endl;
	cout << &b << endl;
	cout << &c << endl;
	cout << &d << endl;
	return 0;
}

这里的引用操作的结果就是图中所示的样子：

2.引用的特性

• 引用在定义时必须初始化

• 一个变量可以有多个引用

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

#include<iostream>
using namespace std;
int main()
{
	int a = 10;
	//int& ra;
	//编译报错：“ra”: 必须初始化引用
	int& b = a;
	int c = 20;
	b = c;
	//引用一旦引用一个实体，再不能引用其他实体,引用也不能改变指向
	//所以这里的操作是赋值而不是引用
	
	cout << &a << endl;
	cout << &b << endl;
	cout << &c << endl;
	return 0;
}

结果是a和b的地址一样，c的地址与a和b不同。

3.引用的使用

• 引用在实践中主要是于引用传参和引用做返回值中减少拷贝提高效率和改变引用对象时同时改变被引用对象。

• 引用传参跟指针传参功能是类似的，引用传参相对更方便一些。

• 引用返回值的场景相对比较复杂，我们在这里简单讲了一下场景，还有一些内容后续类和对象章节中会继续深入讲解。

• 引用和指针在实践中相辅相成，功能有重叠性，但是各有特点，互相不可替代。C++的引用跟其他语言的引用(如Java)是有很大的区别的，除了用法，最大的点，C++引用定义后不能改变指向，Java的引用可以改变指向。

• 一些主要用C代码实现版本数据结构教材中，使用C++引用替代指针传参，目的是简化程序，避开复杂的指针，但是很多同学没学过引用，导致一头雾水。

下面给大家举例说明一下引用在各个功能中的使用：

1.交换值，以及顺序表中的应用（引用传参）：

//指针，引用
//大部分情况下引用都可以替代指针，除了一些特殊情况，比如链表的树的节点的定义只能使用指针

#include<iostream>
using namespace std;
//指针来实现交换值
void Swap(int* x, int* y)
{
	int tmp = *x;
	*x = *y;
	*y = tmp;
}
//引用实现交换值
void Swap(int& x, int& y)
{
	int tmp = x;
	x = y;
	y = tmp;
}
int main()
{
	int a = 1, b = 2;
	Swap(&a, &b);//调用指针方法
	cout << a << " " << b << endl;
	Swap(a, b);//调用引用方法
	cout << a << " " << b << endl;
	return 0;
}

这里的两种方法的效果完全等价，使用引用更易理解，更简单。

//引用在顺序表中的应用
#include<iostream>
using namespace std;

typedef struct SeqList
{
	//...
}SL;
//void SLInit(SL* ps, int n = 4)
void SLInit(SL& ps, int n = 4)
{
	//...
}
int main()
{
	SL s;
	//SLInit(&s);
	SLInit(s);//使用引用后就不需要传地址了
	return 0;
}

但是在改用引用实现后，注意在实现的过程中原来使用的一般都是 psl-> ，现在应该使用 psl. 

2.交换指针，以及链表中的应用（引用传参）：

//替代二级指针使用
#include<iostream>
using namespace std;

void Swap(int** pp1, int** pp2)
{
	int* tmp = *pp1;
	*pp1 = *pp2;
	*pp2 = tmp;
}

void Swap(int*& p1, int*& p2)
{
	int* tmp = p1;
	p1 = p2;
	p2 = tmp;
}

int main()
{
	int a = 1, b = 2;
	int* pa = &a;
	int* pb = &b;
	cout << pa << " " << pb << endl;

	Swap(&pa, &pb);
	cout << pa << " " << pb << endl;
	Swap(pa, pb);
	cout << pa << " " << pb << endl;
	return 0;
}

这里能明显感觉到，引用的方法比指针更方便，更易理解。

//在链表中的使用
#include<iostream>
using namespace std;

typedef struct SListNode
{
	struct SListNode* next;
	int val;
}SLTNode,*PSLTNode;
//这里的SLTNode表示struct SListNode
//这里的*PSLTNode表示SListNode*
//同时等价于下面这两句：
//typedef struct SListNode SLTNode;
//typedef struct SListNode* PSLTNode;

////以前使用二级指针的实现方法
//void SLTPushBack(SLTNode** pphead, int x)
//{
//	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
//	if (*pphead == NULL)
//	{
//		*pphead = newnode;
//	}
//	else {
//		//找到尾节点，newnode连接到尾节点...
//	}
//}

//void SLTPushBack(PSLTNode& phead, int x)，有时候书上会这样写
void SLTPushBack(SLTNode*& phead, int x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (phead == NULL)
	{
		phead = newnode;
	}
	else {
		//找到尾节点，newnode连接到尾节点...
	}
}
int main()
{ 
	SLTNode* plist = NULL;
	////用二级指针
	//SLTPushBack(&plist, 1);
	//SLTPushBack(&plist, 2);
	//SLTPushBack(&plist, 3);
	//SLTPushBack(&plist, 4);

	//用引用
	SLTPushBack(plist, 1);
	SLTPushBack(plist, 2);
	SLTPushBack(plist, 3);
	SLTPushBack(plist, 4);
	return 0;
}

这里额外说一下下面代码中的*PSLTNode：

typedef struct SListNode
{
    struct SListNode* next;
    int val;
}SLTNode,*PSLTNode;

这里的*PSLTNode表示SListNode*，即用重命名可表示为typedef struct SListNode* PSLTNode;

这里通常会在教材这样的书上出现，其意为用PSLTNode来代表更难理解的指针类型，但由于我们没接触过这样的表示方法，所以看到时容易将我们看懵。

3.无法使用引用的情况：

在大部分的场景下，引用都可以代替指针使用，但是在链表、树的节点定义位置，只能使用指针，无法使用引用代替指针。

这是因为：C++中的引用不能改变指向，而节点一定存在改变指向的场景

4.传值返回和传引用返回

1）传值返回：

#include<iostream>
using namespace std;
//传值返回
int func()
{
	int ret = 0;
	//...
	return ret;
}
int main()
{
	int x = func();//这里x接受的是ret的拷贝值，ret在func函数销毁时就没了，通过临时变量带出
	//func() += 1;//，因为func函数已经销毁了，所以这里是无法修改的，具有常性
	return 0;
}

注意：这里ret返回给x的不是ret本身，而是ret的临时拷贝！这个临时变量可能是在寄存器中临时存储的，由寄存器带回。

2）传引用返回：

#include<iostream>
using namespace std;
//传引用返回
int& func()
{
	int ret = 0;
	//...
	return ret;
}
int main()
{
	int x = func();
	cout << x << endl;
	return 0;
}

这里使用传引用返回实际上是错误的，这里的x可能是0或者随机值（具体因编译器而定）。

这里的返回值tmp是ret的别名，而func函数栈帧在使用完后销毁了，还给了操作系统，但tmp还是指向这块空间，后续如果有别人使用了这块空间，返回值就会受到影响。所以这里的传引用返回很危险，相当于野指针的访问！

下面给大家一个例子，来更好的说明这个问题：

#include<iostream>
using namespace std;

int& func1()
{
	int ret = 0;
	// ...
	return ret;
}

int& func2()
{
	int y = 456;
	// ...
	return y;
}

int main()
{
	int& x = func1();
	cout << x << endl;
	func2();
	cout << x << endl;
	//明明没有修改x，但x的值还是会为y
	//这是因为fun1函数栈帧销毁后还给了操作系统，但是func2又使用了这块空间
	return 0;
}

这里就是因为在调用完func1后，func1销毁了，而后面的func2又使用了这个空间，将x的值改为了y，而这个引用指向的还是这块空间，所以最后x的值变成了y。

关于传引用返回的两个问题：

1.func函数销毁了之后为什么还可以访问？

因为销毁了并不代表空间没了，内存空间是可以反复使用的，销毁的本质是还给操作系统，跟租房的道理一样，返回的别名就相当于偷偷留了把钥匙，但是这样是不可取的。

2.这里相当于野指针的访问为什么没报错？

越界不一定报错，越界写可能会报错，在数组中存在越界抽查这个现象。所以我们有时候编译器不会在这里报错的。

int a[10];
// 越界抽查
a[10] = 1;
a[11] = 1;
a[15] = 1;

5.传引用返回在实践中的使用场景：

这里以顺序表为例，仍然使用简化版，大家如果想了解更全的代码可以去博主前面的文章里找。

SeqList.h

#pragma once
#include<iostream>
#include<stdlib.h>

typedef struct SeqList
{
	int* arr;
	int size;
	int capacity;
}SL;

void SLInit(SL& pls, int n = 4);
void SLPushBack(SL& pls, int x);
int SLFind(SL& pls, int x, int i = 0);
int& SLat(SL& pls, int i);//这里使用引用就可以读取i位置的值，还能修改
void SLModify(SL& pls, int i, int x);//这个不好用

SeqList.cpp

#include"SeqList.h"

void SLInit(SL& pls,int n)//前面声明给了缺省参数，这里不能再给了
{
	pls.arr = (int*)malloc(n * sizeof(int));
	pls.size = 0;
	pls.capacity = n;
}
void SLPushBack(SL& pls, int x)
{
	//...
	pls.arr[pls.size++] = x;
}
//返回下标
int SLFind(SL& pls, int x, int i)
{
	while (i < pls.size)
	{
		//...
	}
	//...
	return -1;
}
//寻找下表为i的元素
int& SLat(SL& pls, int i)//加上引用就可以实现寻找并且修改值了
{
	//...
	return pls.arr[i];//这里可以使用引用返回是因为它是结构体中的一个在堆的数据
}
//不使用引用的话，只能这样修改下标为i的元素
void SLModify(SL& pls, int i, int x)
{
	//...
	pls.arr[i] = x;
}

test.cpp

//那我们什么时候可以使用到这个传引用返回呢
//我们拿顺序表这个数据结构为例子，当然栈也可以

#include"SeqList.h"
#include<iostream>
using namespace std;

int main()
{
	SL s;
	SLInit(s, 10);
	for (int i = 0; i < 10; i++)
	{
		SLPushBack(s, i);
	}

	for (int i = 0; i < 10; i++)
	{
		cout << SLat(s, i) << " ";
	}
	cout << endl;

	// 把顺序表第i个位置的值修改为x
	int i = 0;
	int x = 0;
	cin >> i;
	cin >> x;

	//SLModify(s, i, x);//用来修改下标为i的值，不好用
	SLat(s, i) = x;//用了返回引用这里就可以直接修改值了

	for (int i = 0; i < 10; i++)
	{
		cout << SLat(s, i) << " ";
	}
	cout << endl;
	return 0;
}

6.知识点补充：

指针和引用在语法层面和底层的差异与相同点：

在语法层面：引用不额外开辟空间，指针需要额外开辟空间

底层：在底层来看，两者几乎是一致的，比如下面这个代码转到反汇编来看

#include<iostream>
using namespace std;

int main()
{
	int i = 0;
	//语法层面上引用不开空间，指针开空间
	int& j = i;
	int* p = &i;
	j++;
	(*p)++;

	//但是我们转到反汇编，可以看出其实引用的底层就是指针，两个指令的反汇编代码都差不多，这个需要仔细观察一下
	return 0;
}

发现指针和引用是差不多的，所以在底层来看，指针和引用几乎一致。

4.const引用

• 可以引用一个const对象，但是必须用const引用。const引用也可以引用普通对象，因为对象的访问权限在引用过程中可以缩小，但是不能放大。

• 不需要注意的是类似 int& rb = a*3; double d = 12.34; int& rd = d; 这样一些场景下a*3的和结果保存在一个临时对象中， int& rd = d 也是类似，在类型转换中会产生临时对象存储中间值，也就是时，rb和rd引用的都是临时对象，而C++规定临时对象具有常性，所以这里就触发了权限放大，必须要用常引用才可以。

• 所谓临时对象就是编译器需要一个空间暂存表达式的求值结果时临时创建的一个未命名的对象，C++中把这个未命名对象叫做临时对象。

1.引用和指针的权限放大和缩小问题（放大不行，缩小可以）：

#include<iostream>
using namespace std;

int main()
{
	const int a = 0;
	//这里就是权限放大
	//int& b = a;//因为a被const修饰了不能修改，而b没有被限制，以至于权限放大了
	const int& b = a;

	//权限缩小是允许的
	int c = 0;
	const int& d = c;//c既可以读也可以写，没有限制，而c的引用d不能被修改

	const int k = 0;
	int e = k;//这里不是权限放大，而是拷贝赋值

	return 0;
}

//权限的放大和缩小，只存在于const指针和const引用
//我们再来看看指针
#include<iostream>
using namespace std;

int main()
{
	const int a = 0;
	const int* p1 = &a;
	//int* p2 = p1;
	//这个也属于权限的放大，得写成下面这样
	const int* p2 = p1;

	//但是权限缩小还是可以的
	int c = 0;
	int* p3 = &c;
	const int* p4 = p3;

	return 0;
}

2.const修饰引用传参：

作为函数参数时如果不是为了改变形参从而影响实参，那么就用const修饰引用再传参，这样传参的时候选择的类型就更多 。

#include<iostream>
using namespace std;

void func1(const int& a)
{
    //...
}
void func2(int& a)
{
    //...
}
int main()
{
	//两个函数传这个参数都可以，第二个函数这里最多也就是权限缩小，是可行的
	int x = 1;
	func1(x);
	func2(x);


	const int y = 2;
	func1(y);
	//func2(y);//不行，这里传const int给int相当于权限放大，是不可行的

	//直接传值的话也是跟上面一样的道理
	func1(3);
	//func2(3);//同样不行
    
	double b = 1.1;
	func1(b);//同样是可行的，涉及隐式类型转换

	return 0;
}

3.涉及类型转换的const引用：

#include<iostream>
using namespace std;

int main()
{
	int i = 0;
	double j = i;
	//此处是可行的，涉及隐式类型转换
	//隐式类型转换(有关联的，如：整型和整型之间，浮点型和整型之间，浮点型和浮点型之间)
	//因为int和double这些本质上都是表示数据大小的。

	//但是没有关联的，比如整型和指针就只能用强制类型转换,如下
	int p = (int)&i;

	//在引用部分来看
	int n = 0;
	//double& m = n;//编译是不通过的（属于权限的放大）
	const double& m = n;//可行

	return 0;
}

关于为什么double& m = n;部分属于权限的放大？

这是因为在类型转换过程中，会产生一个临时对象来保存中间值。所以在代码中double& m引用的对象是一个临时变量，在C++中这个临时变量具有常性（与被存储在寄存器中有关），就像是被const修饰了一样。所以我们这里如果直接操作的话，就会出现权限放大的错误，我们必须使用常引用(即const修饰)。下面再给大家用图解释一下：

5.指针和引用的关系（面试考点）

C++中指针和引用就像两个性格迥异的亲兄弟，指针是哥哥，引用是弟弟，在实践中他们相辅相成，功能有重叠性，但是各有自己的特点，互相不可替代。

• 语法概念上引用是一个变量的取别名不开空间，指针是存储一个变量地址，要开空间。

• 引用在定义时必须初始化，指针则是建议初始化，但是语法上不是必须的。

• 引用在初始化时引用⼀个对象后，就不能再引用其他对象；而指针可以在不断地改变指向对象。

• 引用可以直接访问指向对象，指针需要解引用才能访问指向对象。

• sizeof中含义不同，引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节，64位下是8byte)

• 指针很容易出现空指针和野指针的问题，引用很少出现，引用使用起来相对更安全一些。

结语：

本篇博客就到此结束了，主要给大家分享了C++的参数缺省，函数重载以及引用的知识点，内容很多需要大家花点时间理解学习。到此，C++的入门部分就完工了，接下来我们会更深一步的来学习C++。如果文章对你有帮助的话，欢迎评论，点赞，收藏加关注，感谢大家的支持。