【C++】函数重载/缺省参数/内联/引用等相关知识详细梳理

1.缺省参数

1.1缺省参数的概念

        缺省参数是声明或定义函数时为函数的参数指定的一个缺省值。在调用该函数时，如果没有指定的实参，则采用该形参的缺省值，否则使用指定的实参

        例如：

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

int main()
{
	func();//不传参，形参用缺省值初始化
	func(2);//传参，形参是实参的拷贝
	return 0;
}

        输出结果：

1.2缺省参数种类

        1.2.1全缺省参数

        全缺省参数即所有参数都是缺省参数

        例如：

void func(int a = 0,int b = 2)
{
	
}

        1.2.2半缺省参数

        半缺省参数是介于全缺省和不缺省参数之间的一种，即参数中既有缺省参数，也有不缺省的参数。

void func(int a,int b = 2,int c = 3)
{
	
}

        注意：半缺省的次序一定是从右往左缺省。（否则会有歧义）

        例如：

void func(int a= 1,int b,int c=3)
{
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;
}

int main()
{
	func(10,12);//此时运行时会报错error C2548: “func”: 缺少形参 2 的默认实参
	return 0;
}

        报错的原因是不知道两个值是传给形参a和b还是b和c。

        而从右往左缺省就能避免这种歧义。

1.3使用缺省参数需要注意

        1. 半缺省参数必须从右往左依次来给出，不能间隔着给
        2. 缺省参数不能在函数声明和定义中同时出现（一般只在声明里写）

//a.h
void Func(int a = 10);//函数声明
// a.cpp
void Func(int a = 20)//函数定义
{}
// 注意：如果生命与定义位置同时出现，恰巧两个位置提供的值不同，那编译器就无法确定到底该
//用那个缺省值。

        3. 缺省值必须是常量或者全局变量
        4. C语言不支持（编译器不支持）

2.函数重载 

        自然语言中，一个词可以有多重含义，人们可以通过上下文来判断该词真实的含义，即该词被重载了。

        函数重载就是函数名的一词多义，具体表现在函数的参数不同。

2.1函数重载的概念

        函数重载：是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数 或 类型 或 类型顺序)不同，常用来处理实现功能类似数据类型
不同的问题。

        例如：

#include<iostream>
using namespace std;
// 1、参数类型不同
int Add(int left, int right)
{
    cout << "int Add(int left, int right)" << endl;
    return left + right;
}
double Add(double left, double right)
{
    cout << "double Add(double left, double right)" << endl;
    return left + right;
}

// 2、参数个数不同
void f()
{
    cout << "f()" << endl;
}
void f(int a)
{
    cout << "f(int a)" << endl;
}

// 3、参数类型顺序不同
void f(int a, char b)
{
    cout << "f(int a,char b)" << endl;
}
void f(char b, int a)
{
    cout << "f(char b, int a)" << endl;
}

int main()
{
    Add(10, 20);
    Add(10.1, 20.2);
    f();
    f(10);
    f(10, 'a');
    f('a', 10);
    return 0;
}

注意：同类型缺省参数和不缺省不算不同类型，不可以重载。

           返回值类型不同其他相同的函数也不能重载。

2.2C++支持函数重载的原理

        C语言不支持函数重载，C++支持函数重载。

        要理解为什么，首先要理解可执行程序生成的过程：

        预处理 -> 编译 -> 汇编 -> 链接 -> 可执行程序

        如果像上图一样有多个文件同时编译，假设有文件a.cpp和b.cpp，在a中声明了函数Func并且并没有定义，将函数的定义写在文件b，如果在a中调用函数Func，这时在编译后链接前，目标文件a.o中是没有函数Func的地址的，因为Func的定义在b文件中，也就是目标文件b.o中。（在a文件的编译过程中，编译器不知道函数Func的地址，会暂时搁置）。

        于是链接这一步就会去其他文件中找函数的地址，这一步也叫重定位。

        编译器是如何知道其他文件中定义的函数哪个是我们要的呢？这时就牵扯到了函数名修饰规则，也是C++之所以支持函数重载的原因。

        下面举例说明：

        有如下代码：

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

void func(int a,double b,int* p)
{}

int main()
{
    Add(1,2);
    func(1,2,0);

    return 0;
}

        C语言编译器编译后的汇编：

        结论：在Linux下，采用gcc编译后，函数名称的修饰规则是<原函数名>。

        C++编译器编译后的汇编：

        结论：在Linux下，采用g++编译后，函数名称的修饰规则是<_Z + 函数长度 + 函数名 + 类型首字母按顺序排列>

        ps：不同编译器的函数名称修饰规则有所差异。

        结论：可以看到，C和C++函数修饰名称有所不同，C只通过函数名辨别函数，而C++在C语言的基础上做了优化，追加了参数状态的修饰方法，这也是C++能支持函数重载而C不能支持的原因。

3.内联函数

3.1内联的概念

        以inline（关键字）修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开函数，没有函数调用建立栈帧的开销，内联函数可以提升程序运行的效率。

        例如：

int Add(int left, int right)
{
	return left + right;
}
int main()
{
	int ret = 0;
	ret = Add(1, 2);
	return 0;
}

        可以看到，函数调用时会有一个call的汇编指令。

        在改为内联函数后呢？

        可以看到没有call这一句指令了，这是因为函数在该位置展开了，这一步在编译时就会完成。

3.2内联函数的特性

        为了用好内联函数，我们还得了解内联函数的特性。

        1. inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会
用函数体替换函数调用，缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运
行效率。

        2. inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建
议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不
是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。
《C++prime》第五版关于inline的建议：
        内联说明只是向编译器发出的一个请求，编译器可以选择忽略这个请求

        一般来说，内联机制用于优化规模较小，流程直接，频繁调用的函数。很多编译器都不支持内敛递归函数，而且一个75行的函数也不大可能在调用点内联的展开。

        3.inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址
了，链接就会找不到。（结合上面的编译链接过程理解）

// F.h
#include <iostream>
using namespace std;

inline void f(int i);

// F.cpp
#include "F.h"
void f(int i)
{
cout << i << endl;
}
// main.cpp
#include "F.h"
int main()
{
f(10);
return 0;
}
// 链接错误：main.obj : error LNK2019: 无法解析的外部符号 "void __cdecl
//f(int)" (?f@@YAXH@Z)，该符号在函数 _main 中被引用

        4.内联函数也是C++替代宏函数的推荐方法。

4.引用

        C语言里有指针，指针的指针，指针的指针的指针，同时还有一堆麻烦的解引用操作，为了让代码的可读性更强，写起来更方便，C++提出了引用。

4.1引用的概念

        引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。

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

void TestRef()
{
int a = 10;
int& ra = a;//<====定义引用类型
printf("%p\n", &a);
printf("%p\n", &ra);//可以看到二者输出同一地址
}

        注意：引用类型必须和引用实体为同一类型。

4.2引用的特性

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

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

        3.一个引用变量一旦引用一个实体，就不能再引用其他实体。

void TestRef()
{
int a = 10;
// int& ra; // 该条语句编译时会出错
int& ra = a;
int& rra = a;
printf("%p %p %p\n", &a, &ra, &rra);
}

4.3引用中常遇问题

1.常引用

void TestConstRef()
{
const int a = 10;
//int& ra = a; // 该语句编译时会出错，a为常量，引用的过程中权限放大了
const int& ra = a;
// int& b = 10; // 该语句编译时会出错，b为常量，引用的过程中权限放大了
const int& b = 10;
double d = 12.34;
//int& rd = d; // 该语句编译时会出错，类型不同
const int& rd = d;
}

        重点说一下为什么const int& rd = d类型不同却可以正常运行，这里d隐式类型转换为整型，会用临时变量来保存，所以这时rd引用的实际上是临时变量，临时变量是只读不可写的，而用const修饰后的int就符合要求了，这也是为什么int & rd = d不行而const int& rd = d却可以。

2.引用对象已销毁

         例如：

int& Add(int a, int b)
{
    int c = a + b;
    return c;
}
int main()
{
    int& ret = Add(1, 2);
    cout << "Add(1, 2) is :"<< ret <<endl;
    return 0;
}

 以上代码运行出现随机值，原理类似于野指针（后面会展开讲引用的原理），可以借助函数栈帧的内容分析，这里不展开说了，由于ret引用了已经销毁的空间而产生了随机值。

4.4引用的使用场景 

//1.做参数
void Swap(int& left, int& right)
{
    int temp = left;
    left = right;
    right = temp;
}

//2.做返回值
int& Count()
{
    static int n = 0;
    n++;
    // ...
    return n;
}

4.5引用和指针的区别（引用的原理） 

4.5.1引用的原理：

在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。

但是在底层实现上实际上引用是消耗空间的，因为引用的实现其实是用的指针。

举例说明：

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

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

 结论：引用在底层是指针，从汇编角度来看，使用引用和还是指针没有区别。

4.5.2区别 

引用和指针的不同点:

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

要点：牢记引用是“取别名”而指针是取地址。