【C++】函数重载原理 + 引用 + 内联函数 - 详解 — 入门篇（2）????1. 函数重载：????2. C++ & C语言相互调用：????3. 引用：????4. 内联函数（inline）：????5. 关键字 auto + nullptr：

62 阅读 0 评论 41 点赞

我是靠谱客的博主朴素书本，最近开发中收集的这篇文章主要介绍【C++】函数重载原理 + 引用 + 内联函数 - 详解 — 入门篇（2）????1. 函数重载：????2. C++ & C语言相互调用：????3. 引用：????4. 内联函数（inline）：????5. 关键字 auto + nullptr：，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

文章目录

????1. 函数重载：
- - 1.1 函数重的载概念
  - 1.2 函数重载的原理（重点）
????2. C++ & C语言相互调用：
- - 2.1 extern " C " 的概念
  - 2.2 extern " C " 的使用
  - - (1) C++ 调用 C语言
    - (2) C语言调用 C++
????3. 引用：
- - 3.1 引用的概念
  - 3.2 引用的特性
  - - (1) 修饰的常引用
  - 3.3 引用的使用场景
  - - (1) 做参数
    - (2) 做返回值
  - 3.4 引用和指针的不同点
????4. 内联函数（inline）：
????5. 关键字 auto + nullptr：
- - 5.1 auto
  - 5.2 nullptr

????1. 函数重载：

1.1 函数重的载概念

1.概念：

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

2.形式：

#include<iostream>
using namespace std;

void Swap(int* pa, int* pb)
{
	int tmp = *pa;
	*pa = *pb;
	*pb = tmp;
}

void Swap(double* pa, double* pb)
{
	double tmp = *pa;
	*pa = *pb;
	*pb = tmp;
}

void Swap(char* pa, char* pb)
{
	char tmp = *pa;
	*pa = *pb;
	*pb = tmp;
}

int main()
{
	int a = 1, b = 2;
	double c = 1.22, d = 2.33;
	char ch1 = 'a', ch2 = 'b';

	Swap(&a, &b);
	Swap(&c, &d);
	Swap(&ch1, &ch2);

	cout << "a = " << a << "," << "b = " << b << endl;
	cout << "c = " << c << "," << "d = " << d << endl;
	cout << "ch1 = "  << ch1 << "," << "ch2 = " << ch2 << endl;

	return 0;
}

运行结果：
在这里插入图片描述

可见在C++中，同名函数是可以同时存在的
这样相同功能的函数，就不需要和C语言那样要设置不同的函数名了

1.2 函数重载的原理（重点）

说到函数重载的原理，我们就需要了解编译器大概是如何工作的，计算机是如何认识我们写的C语言 / C++的代码，接下来我们家好好讲讲程序的编译和运行的过程。

1.原理：

test.c 、add.c，.c结尾的文件为C语言的源文件
test.ext，.exe结尾的文件是可执行文件
这里是用C语言的编译器来做演示，若是C++的编译器，源文件是.cpp结尾的

在这里插入图片描述
编译器就是将代码翻译成CPU所认识的机器语言

具体过程如下图：

在这里插入图片描述

. c 的文件是源文件，里而放的是代码
预编译 (预处理)：.i 的文件是. c的文件经过”预编译”(预处理)生成的文件，代码的头文件被展开，注释被去掉(或者是被空格替换)，宏定义被替换
编译：. s的文件是. i的文件经过”编译”生成的文件，C语言代码被转化成” 汇编代码”，这里进行语法分析，词法分析，语义分析，符号汇总
这个过程参考 ”编译原理“ 这门课程，参考书籍 《程序员的自我修养》 ，每一个具有独立意思的符号被提取出来，生成 — 一个叫语法树的东西
汇编：. obj的文件也叫目标文件，是. s的文件经过"汇编”生成的文件，将汇编代码转换成”二进制指令” ，生成符号表
链接：将多个.obj的目标文件再加上链接库进行相关的链接工作，这里进行合并段表，符号表的合并和重定位

符号表的形成：
在这里插入图片描述

符号表的生成和作用：

每个源文件中函数被定义时，每个函数都有自己的地址
符号表就将函数名和函数的地址记录下来
当函数的定义被放在其他的源文件中时，而在该源文件中又调用了这个函数时
调用函数的源文件在编译的过程中形成的符号表会记录这个函数的名字，地址会给一个填充值地址
当每个源文件都生成对应的目标文件.obj之后
(重点) 在最终的链接过程中会发生一次符号表的合并和重定位，在这个过程当中会根据符号表中的函数名，上述的填充值地址会去在所有生成的符号表中去找被调用函数的地址，最终将所有目标文件中的符号表汇总在一个符号表中，符号表的合并和重定位

解释：

调用一个函数的时候，函数名字是不重要的，重要的是函数的地址，当调用一个函数的时候会拿着函数名在各个文件生成的符号表中去找函数的地址，找到了的话就在调用该函数的那个文件生成的符号表中，在调用函数的后面将找到的函数地址填在后面，如果一个函数名对应两个地址的话就会出现歧义，就确定不了要调用的是哪一个函数吗，如下图：

在这里插入图片描述

这也就是为什么在C语言的编译器中，main函数所在的源文件中即使没有函数的声明，也能调用非本源文件的函数，不过在C++编译器中是过不了的，因为C++的编译器检查的更严格，没有声明在编译阶段就过不了，会报语法错误。

多个目标文件进行链接的时候会通过符号表
查看来自外部的符号是否真是存在
如果不存在会报链接错误，找不到该符号(无法解析外部符号)

补充：
在这里插入图片描述

段表的合并大概了解一下，就是每个源文件都有几个相同的或类似的段，在链接的时候会将几个源文件中几个相同的段合并，具体过程大家感兴趣可以去自主研究一下……

2.C++函数的命名规则：

在Linux操作环境中：

(1) C语言在生成符号表时的特点：

C语言在形成符号表的时候，符号表中的函数名就是定义时的函数名
函数名是没有被修饰过的
所以C语言不支持同名函数，会一起歧义，命名冲突

(2) C++在生成符号表时的特点：

C++在形成符号表的时候，符号表中的函数名并非定义时候的函数名
符号表中的函数名是被修饰过了的
修饰规则：【_Z + 函数长度 + 函数名 + 类型首字母】— （Linux环境下）
所以才有要求：这些同名函数的形参列表(参数个数或类型或顺序)必须不同

Windows环境下的命名规则：
在这里插入图片描述
3.为什么C语言不支持函数重载：

因为C语言中的函数名就是用的原来函数的名字，在编译阶段就会报错
因为在 符号表生成的时候就有问题
有可能 两个不同的函数地址但是它们的函数名却相同
在链接的过程中符号表的重定位会出现一个函数名有两个函数地址

4.为什么却省参数要在声明中给默认值：

当声明和定义分离的话：

因为在调用函数的时候，函数要向上查找这个函数是否存在
函数的声明是一个承诺，承诺有这个函数的存在
但是具体函数是否存在还得看函数的定义
如果是用到了缺省参数的话，当调用到这个函数的时候
会先向上去找声明，函数调用的时候不传数值，但是声明中函数有形参
声明和调用匹配不上，产生声明中有形参但是函数并没有传参，在编译阶段就会报错语法错误
缺省参数是在编译阶段处理的

????2. C++ & C语言相互调用：

C++是兼容C语言的，因为C++是支持函数重载，而C语言是不支持函数重载的

2.1 extern " C " 的概念

有时候在C++工程中可能需要将某些函数按照C的风格来编译，在函数前加extern “C”，意思是告诉编译器，将该函数按照C语言规则来编译。
比如：tcmalloc是google用C++实现的一个项目，他提供tcmallc()和tcfree 两个接口来使用，但如果是C项目就没办法使用，那么他就使用extern “C”来解决。

2.2 extern " C " 的使用

在有些场景底下，需要我们用C++写的程序去调用C++写的库，或者是C语言去调用C++写的库，它们在相互调用的时候，因为各自语法不同，一个可以函数重载和缺省参数，而另一个却不能……

(1) C++ 调用 C语言

当C++去调用C库的时候，C++在形成符号表的时候和C语言有所差异
这时候C++编译器就只能按照C语言的方式来对调用的函数形成符号表

如下代码：

//C++ --> C
//告诉C++的编译器，extern"C"声明的函数，是C库，要用C的方式去链接调用
extern"C"
{
       #include"../../22.5.15/22.5.15/Stack.h"
}

(2) C语言调用 C++

这时就不可以像C++调C语言那样用 extern " C " 了，因为C语言中没有 extern " C "

如果是在C++的库中要调用的函数声明前都用 extern C 的话，如下代码：

//初始化
extern "C" void StackInit(ST * ps);
//销毁
extern "C" void StackDestroy(ST* ps);
//进栈
extern "C" void StackPush(ST* ps, STDataType x);
//出栈
extern "C" void StackPop(ST* ps);
//判断栈是否为空
extern "C" bool StackEmpty(ST* ps);
//栈顶的数据
extern "C" STDataType StackTop(ST* ps);
//栈的数据个数
extern "C" int StackSize(ST* ps);

但是这样写还是存在问题，那就是C语言调用的时候，在一开始展开的时候会报错，因为C语言的语法中没有，C语言的编译器就不认识 extern C ,头文件展开之后就会报错

#include"../../22.5.15/22.5.15/Stack.h"

在这里插入图片描述
我们的思路是：无论是C语言调用C++还是C++调用C语言，都是处理C++一方，在C++那一放动手，我们可以利用C++的特性

__cplusplus是C++特有的，而C语言却不具备

我们巧妙地利用 “条件编译和宏” ，如下代码：

方法一：

#ifdef __cplusplus
	#define EXTERN_C extern"C"
#else
	#define EXTERN_C
#endif

//初始化
EXTERN_C void StackInit(ST* ps);
//销毁
EXTERN_C void StackDestroy(ST* ps);
//进栈
EXTERN_C void StackPush(ST* ps, STDataType x);
//出栈
EXTERN_C void StackPop(ST* ps);
//判断栈是否为空
EXTERN_C bool StackEmpty(ST* ps);
//栈顶的数据
EXTERN_C STDataType StackTop(ST* ps);
//栈的数据个数
EXTERN_C int StackSize(ST* ps);

方法二：

#ifdef __cplusplus
extern"C"
	{
#endif
	//初始化
	void StackInit(ST* ps);
	//销毁
	void StackDestroy(ST* ps);
	//进栈
	void StackPush(ST* ps, STDataType x);
	//出栈
	void StackPop(ST* ps);
	//判断栈是否为空
	bool StackEmpty(ST* ps);
	//栈顶的数据
	STDataType StackTop(ST* ps);
	//栈的数据个数
	int StackSize(ST* ps);
#ifdef __cplusplus
	}
#endif

这样就很好的实现了C++和C语言的相互调用了~

????3. 引用：

3.1 引用的概念

1.概念：

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

格式：类型& 引用变量名(对象名) = 引用实体

注意：引用类型必须和引用实体是同种类型的

C++很珍惜关键字和符号，引用没有定义新的关键字
&以前叫取地址，现在加在类型的后面，变量的前面就叫做引用
引用的意思就是取别名
还可以给别名再取别名

举个栗子：

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

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;

	cout << "&a = " << &a << endl;
	cout << "&b = " << &b << endl;
	cout << "&c = " << &c << endl;

	return 0;
}

在这里插入图片描述

解释：

这里a是一个四个字节的空间，里面放了一个整形10
b是这个空间的别名，c是b的别名
也就是说这个空间的名字既是a，也是b，也是c
并且a和b和c的地址相同，因为它们是同一块空间

3.2 引用的特性

引用在定义时必须初始化
一个变量可以有多个引用(多个别名) - 个数没有限制
引用一旦引用一个实体，再不能引用其他实体（一个别名只能是一个变量的别名）

举个栗子：一开始是a的别名，后面就一直是a的别名，就不可能是其他实体的别名了

#include<iostream>
using namespace std;

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

	int* p = &b;

	//1.引用在定义时必须初始化
	//int& d;

	//3. 引用一旦引用一个实体，再不能引用其他实体
	int e = 20;
	b = e;     //这里是把e的值赋值给b呢？还是让b变成e这块空间的别名？
			   //这里必然是赋值 - 是e赋值给b

	return 0;
}

(1) 修饰的常引用

const 是C / C++的关键字，它修饰过一个变量之后该变量就是不可以被改变的，它限定一个变量为只读的，是不能被该写的

1.const修饰指针：

下面代码哪些指针变量是可以修改的，哪些指针变量的解引用是不可以修改的？

int a = 10;
int b = 20;

const int* pa = &a;
int const* pa = &a;
int* const pa = &a;

const int* pb = &b;
int const* pb = &b;
int* const pb = &b;

const 的位置在 “ * ” 的左边，修饰的指针指向的内容
意思是：指针指向的内容不能通过指针来改变 - (不能通过对指针解引用来改变指针指向的内容)
const 的位置在 “ * ” 的右边，修饰的是指针变量本身
意思是：指针变量的内容不能被改变

所以 ( * pa) 和 ( * pb) 是不可以被改写的，pa 和 pb 也是不可以被改写的

2.const修饰引用：

取别名的原则：对原因用的变量，权限只能缩小，不能放大 - 读写权限

(1)场景1：

int main()
{
	//const是只读的，是不能该写的

	//取别名的原则：对原因用的变量，权限只能缩小，不能放大 - 读写权限
	const int x = 20;
	//int& y = x;     //权限的放大 - 变成可读可写的了
	const int& y = x; //权限不变

	int a = 30;       //可读可写
	const int& b = a; //权限的缩小

	cout << b << endl;
	//b = 40;

	return 0;
}

int& y = x； 权限的放大 - 变成可读可写的了，这样写会报错
const int& y = x; 权限不变
权限只能被缩小： 即 “ 可写可读 ” 只能被改成 “ 只读 ”
权限不能被放大： 即不能由 “ 只读 ” 改成 “ 可读可写 “

(1)场景2：

void func(const int& x)
{

}

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

	const int& c = 20;
	double d = 2.2;
	int f = d;     //这个赋值过程中，会存在一个临时变量
	//因为daouble是8个字节，int是4个字节
	//这句代码就是将浮点数整数的部分取出来，给f

	const int& e = d; // e 是临时变量的别名，也就是常变量的别名
	//所以e和d的地址不一样

	//所以要加const，不然权限就被放大了
	//从另一个角度来说，也可以相当于是引用一个常数，所以要加const
	
    func(a);
	func(d);//中间临时变量
	func(c);
	func(e);
	return 0;
}

10是常量，不能修改的，赋值给了a，a不用加const，因为a的改变不会影响10
c是20的别名，因为数字是常量是不能修改的，所以要加const
如果void函数参数不加const的话，就有错因为只有a是可以改写的，其余的权限都会被放大

当一个double类型的值赋值给int类型的时候会发生隐式转换double会丢失精度，2.2赋值给整形的话只保留整数部分的2，小数部分的精度丢失掉
但是在赋值的过程中是先将2.2赋值给一个临时变量，
这个临时变量具有常性，是只读的，不可被修改

const int& e = d; e 是带有常性的临时变量的别名，也就是常变量的别名
所以要加const，不然权限就被放大了

3.3 引用的使用场景

(1) 做参数

1.交换两个变量：

在C语言中如果想用函数实现交换两个变量的话就要将两个变量的地址传过去，通过指针解引用来访问到原来的空间从而实现交换
而C++则可以通过给变量取别名（引用） 来避开使用传指针，这样不仅好理解而且效率更高

代码举例：

#include<iostream>
using namespace std;

void Swap(int& x, int& y)
{
	int tmp = x;
	x = y;
	y = tmp;
}

void Swap(double& x, double& y)
{
	double tmp = x;
	x = y;
	y = tmp;
}

int main()
{
	int a = 0, b = 1;
	Swap(a, b);

	double c = 1.1, d = 2.2;
	Swap(c, d);
	
	cout << a << " " << b << endl;
	cout << c << " " << d << endl;

	return 0;
}

x是a的别名，y是b的别名，x就是a，y就是b
所以x和y交换，就是a和b的交换
同时再配合函数重载，就可以很方便的使用功能类似的函数了

(2) 引用传参比普通传参的效率高很多：

代码证明：

#include<iostream>
#include <time.h>
using namespace std;

struct A
{
	int a[10000];
};

void TestFunc1(A a)
{

}

void TestFunc2(A& a)
{

}

void TestRefAndValue()
{
	A a;

	//以值作为函数参数
	size_t begin1 = clock();
	for (size_t i = 0; i < 10000; i++)
	{
		TestFunc1(a);
	}
	size_t end1 = clock();

	//以引用作为函数参数
	size_t begin2 = clock();
	for (size_t i = 0; i < 10000; i++)
	{
		TestFunc2(a);
	}
	size_t end2 = clock();

	//分别计算两个函数运行结束后的时间
	cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
	cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}

int main()
{
	TestRefAndValue();

	return 0;
}

在这里插入图片描述

可见当传的参数很大的时候，引用传参的优势就显示出来了
C++尽量讲究用引用传参，如果不改变传参的值还要用const引用传参

(2) 做返回值

1.引用返回：

我们一般自定义一个函数的时候，如果函数有一个返回值的话，我们知道函数结束的时候会将创建的栈帧销毁掉，那么那个返回值它是如何返回的呢？

函数返回值，是先将返回值存在小的临时空间中，小值的返回如：4,8 返回是先存在寄存器中
当返回的值很大的时候如： 返回一个结构体的时候就会在上一层栈帧先提前将空间开好

(1)传值返回和传引用返回的区别：

传值返回：会有一个拷贝
传引用返回：没有这个拷贝了，函数返回的直接就是返回变量的别名

(2)代码演示：

演示一：
在这里插入图片描述

为什么要是const int& ret，因为是对临时变量的引用，ret是临时变量的别名，临时变量具有常性，是只读的

演示二：
在这里插入图片描述

中间可以 “认为也产生一个临时变量”，只是这个临时变量的类型是int引用
(这样只是便于理解，具体可能并不是这样)
假设中间名字叫tmp，tmp是n的别名，ret又是tmp的别名，则ret是n的别名
传引用返回就相当于返回的就是n的别名，中间没有开空间
它们的地址一样的，说明返回的就是别名

演示三：

#include<iostream>
using namespace std;

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

	return n;
}

int main()
{
    int& ret = Count();
	
	cout << ret << endl;
	cout << ret << endl;
	cout << ret << endl;

	return 0;
}

先看结果：
在这里插入图片描述
解释：
函数结束的时候会清栈帧空间，有些栈帧就不会清，如：VS，第一次要是随机值也是正常的，因为有可能第一次就清理栈帧了
若Count函数中变量n用static修饰过了的话：

解释：

static修饰过的局部变量n的声明周期变长了
函数结果的时候，n的空间不会被销毁，不会被操作系统回收掉
后续就还可以访问到那一块空间

注意：如果函数返回时，出了函数作用域，如果返回对象还未还给系统，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回

演示四：

#include<iostream>
using namespace std;

int& Add(int a, int b)
{
	//static int c = 0;
	int c = 0;
	c = a + b;

	return c;
}

int main()
{
	int& ret = Add(1, 2);
	Add(3, 4);
	cout << "Add(1, 2) is :" << ret << endl;
	cout << "Add(1, 2) is :" << ret << endl;
	cout << "Add(1, 2) is :" << ret << endl;

	return 0;
}

现象和上述一样，当函数中局部变量已经被回收掉的时候再去访问就是非法的
上述代码不加static的情况，int& ret也叫野引用
不同的编译器建立栈帧的机制不同，所以出现不同的现象也正常

传值返回和传引用返回的比较：

#include<iostream>
using namespace std;

#include <time.h>
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;
}

在这里插入图片描述

因为值返回的是需要拷贝的，而引用返回是不需要拷贝的
当返回的数据占的空间很大时，引用返回的优势就显而易见了

指针和引用底层实现：

其实引用和指针的底层实现是一样的，虽然表面是不同的
但是它们的汇编代码都是一眼的

#include<iostream>
using namespace std;

int main()
{
	int a = 10;
	//语法角度而言：ra是a的别名，没有额外开空间
	//底层的角度：他们是一样的方式实现的
	int& ra = a;
	ra = 20;

	//语法角度而言：pa存储a的地址，pa开了4/8byte空间
	//底层的角度：他们是一样的方式实现的
	int* pa = &a;
	*pa = 20;

	//底层实现都是转换成汇编代码
	return 0;
}

汇编代码一样，见下图：
在这里插入图片描述

3.4 引用和指针的不同点

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

????4. 内联函数（inline）：

1.作用：

（问题） 频繁调用短小的函数，频繁创建栈帧效率不高
内联函数会在调用的地方展开，适用于频繁调用的短小函数
（重点） 如果在上述函数前增加inline关键字将其改成内联函数，在编译期间编译器会用 函数体替换函数的调用

2.C语言是怎样实现该功能的

C语言是使用宏定义解决的
例如：加法函数用宏替换：#define ADD(x, y) ((x) + (y))

缺点：

宏函数晦涩难懂
容易写错的问题
宏不支持调试，不支持类型安全的检查

内联函数的好处：

内联函数支持调试
宏函数的好处是：在调用的地方展开不用建立栈帧

inline int Add(int x, int y)
{
	int z = x + y;
	return z;
}

int main()
{
	Add(1,2);
	
	return 0;
}

创建栈帧时要：保存寄存器，压参数，压返回值，不适合短小频繁使用的小函数

特性：

inline是一种以空间换时间的做法，省去调用函数额开销。所以代码很长或者有循环 / 递归的函数不适宜使用作为内联函数。
inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环 / 递归等，编译器优化时会忽略掉内联。
inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。
递归inline的话就无穷无尽了，长的代码一般超过十行就不要展，具体取决于编译器，inline对编译器是一种建议

当函数的声明和定义分离的时候，调用函数的时候会报错，会报链接错误

原因： 头文件展开，拿到函数声明，当符合内联函数的特质的时候，编译器会将它当做内联函数使用。当头文件展开的时候，该源文件生成的.o文件中不会生成inline修饰过的函数的地址，就不会将它搞到符号表里面去，最后调用的函数拿函数名去找函数的地址时会找不到，因为没有函数的地址，就报链接错误了

方法：将声明和定义都放在.h头文件中，或者直接就在头文件中写好inline函数的定义不要函数的声明

????5. 关键字 auto + nullptr：

5.1 auto

1.概念：

C++11中，标准委员会赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型，指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得
因为是在C++11之后推出的语法，所以只有比较新的编译器才会支持这种新的语法

2.代码演示：

再介绍一个关键字：typeid

这个关键字是可以返回变量的类型

int main()
{
	const int a = 10;
	auto b = &a;
	auto c = 'a';
	const auto& d = TestAuto();
	int x = 1;
	auto* m = &x;//指定类型是一种指针的类型，必须赋值是一种指针
	//typeid - 可以看一个变量的类型

	cout << typeid(b).name() << endl;
	cout << typeid(c).name() << endl;
	cout << typeid(d).name() << endl;
	cout << typeid(m).name() << endl;

	//auto e; //无法通过编译，使用auto定义变量时必须对其进行初始化
	return 0;
}

在这里插入图片描述
在以后的学习中会遇到类型名字很长的请款就需要用到auto偷个懒

注意：

auto不能作为函数的参数
auto不能作为形参类型，因为编译器无法对形参的实际类型进行推导
auto不能直接用来声明数组
为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法
auto在实际中最常见的优势用法就是跟以后会讲到的C++11提供的新式for循环，还有lambda表达式等进行配合使用

auto另一个用法 - 范围for：

int main()
{
	int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	
	//遍历数组
	//C语言的方式
	for (int i = 0; i < sizeof(array) / sizeof(array[0]); i++)
	{
		array[i] *= 2;
	}

	for (int i = 0; i < sizeof(array) / sizeof(array[0]); i++)
	{
		cout << array[i] << " ";
	}
	cout << endl;

	for (auto e : array)//e是数组中每个值的拷贝，想改改变的话就用引用用别名
	{
		e /= 2;
	}
	
	//C++的方式
	//C++11中的范围for
	for (auto e : array)
	{
		cout << e << " ";

	}

	cout << endl;

	return 0;
}

可以不用auto，也可以指定类型，也不一定非要用e
e只是一个变量名，一般用因为元素这个单词的首字母element是e
原理讲了迭代器之后才能理解，自动遍历
依次自动取array中的数据赋值给e，自动判断结束

5.2 nullptr

C语言中的空指针是NULL，实际上它是一个宏
在这里插入图片描述
可以看到，NULL可能被定义为字面常量0，或者被定义为无类型指针(void)的常量*。不论采取何种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦，比如：

#include<iostream>
using namespace std;

void f(int)
{
	cout << "f(int)" << endl;
}

void f(int*)
{
	cout << "f(int*)" << endl;
}

int main()
{
	f(0);
	f(NULL);

	return 0;
}

在这里插入图片描述
在一些特定的场景下就会出现问题，宏替换将NULL替换成了0

补充：

在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的。
在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。

综上所述：

为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr

最后

以上就是朴素书本为你收集整理的【C++】函数重载原理 + 引用 + 内联函数 - 详解 — 入门篇（2）????1. 函数重载：????2. C++ & C语言相互调用：????3. 引用：????4. 内联函数（inline）：????5. 关键字 auto + nullptr：的全部内容，希望文章能够帮你解决【C++】函数重载原理 + 引用 + 内联函数 - 详解 — 入门篇（2）????1. 函数重载：????2. C++ & C语言相互调用：????3. 引用：????4. 内联函数（inline）：????5. 关键字 auto + nullptr：所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。

本文分类：C++
浏览次数：62 次浏览
发布日期：2023-09-09 17:45:10
本文链接：https://www.kaopuke.com/article/k-p-k_14_uzo_6_fx_14_j_22_0.html

【C++】函数重载原理 + 引用 + 内联函数 - 详解 — 入门篇（2）????1. 函数重载：????2. C++ & C语言相互调用：????3. 引用：????4. 内联函数（inline）：????5. 关键字 auto + nullptr：

概述

文章目录

????1. 函数重载：

1.1 函数重的载概念

1.2 函数重载的原理（重点）

????2. C++ & C语言相互调用：

2.1 extern " C " 的概念

2.2 extern " C " 的使用

(1) C++ 调用 C语言

(2) C语言调用 C++

????3. 引用：

3.1 引用的概念

3.2 引用的特性

(1) 修饰的常引用

3.3 引用的使用场景

(1) 做参数

(2) 做返回值

3.4 引用和指针的不同点

????4. 内联函数（inline）：

????5. 关键字 auto + nullptr：

5.1 auto

5.2 nullptr

最后

评论列表共有 0 条评论

发表评论取消回复

【C++】函数重载原理 + 引用 + 内联函数 - 详解 — 入门篇（2）????1. 函数重载：????2. C++ & C语言 相互调用：????3. 引用：????4. 内联函数 （inline）：????5. 关键字 auto + nullptr：

概述

文章目录

????1. 函数重载：

1.1 函数重的载概念

1.2 函数重载的原理（重点）

????2. C++ & C语言 相互调用：

2.1 extern " C " 的概念

2.2 extern " C " 的使用

(1) C++ 调用 C语言

(2) C语言 调用 C++

????3. 引用：

3.1 引用的概念

3.2 引用的特性

(1) 修饰的常引用

3.3 引用的使用场景

(1) 做参数

(2) 做返回值

3.4 引用和指针的不同点

????4. 内联函数 （inline）：

????5. 关键字 auto + nullptr：

5.1 auto

5.2 nullptr

最后

相关文章

评论列表共有 0 条评论

发表评论 取消回复

【C++】函数重载原理 + 引用 + 内联函数 - 详解 — 入门篇（2）????1. 函数重载：????2. C++ & C语言相互调用：????3. 引用：????4. 内联函数（inline）：????5. 关键字 auto + nullptr：

????2. C++ & C语言相互调用：

(2) C语言调用 C++

????4. 内联函数（inline）：

发表评论取消回复