文章目录
一、内联函数
什么是内联函数
以**
inline修饰的函数叫做内联函数，编译时C++编译器会在**调用内联函数的地方展开，没有函数调用建立栈帧的开销，内联函数提升程序运行的效率。
为什么存在内联函数
我们知道，普通的函数需要建立栈帧空间
因此，可以利用宏来定义一些小的函数（行数较少的）
这样，函数调用的时候其实就是语句的直接替换，而不存在函数栈帧的创建和销毁
比如，一个实现两个数相加的函数
//普通函数
int Add(int x,int y)
{
return x+y;
}
//宏函数形式
#define ADD(a,b) ((a)+(b))
对比于普通函数来说，宏的优点就很明显了
- 使用宏函数，可以不用建立栈帧，减小系统开销，提高运行效率
但是显然，宏也有缺点
- 相比于函数，宏定义的函数可读性差，函数体复杂
- 宏函数参数没有类型检查，容易出现bug（如不同类型的相加）
- 宏在预处理阶段就直接整体替换展开了，不方便调试
所以，为什么存在内联函数？
内联函数的存在就是为了解决宏的缺点，同时保留宏的优点
内联函数的查看
既然你说，内联函数不会调用函数，直接展开
有什么证据呢？
如图所示，这是没有加inline修饰的函数
可以看到反汇编中存在call Add这条命令，也就是会调用函数
但是如果加了inline修饰呢？
注意
- 如果在release模式下，查看汇编代码中是否存在call Add即可
- 但是如果在debug模式，需要进行设置，因为
inline属于一种优化，debug模式下为了方便调试默认不会进行优化
以VS2019为例，关闭优化：
可以看到，关闭优化之后，执行到Add函数的时候，并没有执行优化
说明inline是存在的
内联的注意事项
inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用缺陷：可能会使目标文件变大
优势：少了调用开销，提高程序运行效率
inline对于编译器只是一个建议，不同编译器关于inline实现机制可能不同一般函数规模较小（展开汇编 小于10行），没有递归。并且会频繁调用的函数，编译器会采纳
inline的建议。否则编译器会忽略inline的建议。因为如果展开汇编代码很多的话，会导致程序的大小变大！比如：
如果一个函数有100行，调用10000次 比较程序的语句数量 不展开：10000个call + 100 个指令 展开：100*10000 条指令 可执行程序会明显变大而可执行程序变大的结果就是：
比如更新《王者荣耀》这个游戏，500MB的更新内容硬是要更新2个G，难受不难受😫
如《C++primer》中所述
inline的声明和定义不要分离，如果在.h中声明inline func()，然后在test.cpp中进行定义，main.cpp中进行调用。那么当调用的时候，因为有头文件所以编译可以通过.但是链接的时候，就去test.cpp生成的目标文件的符号表中去找函数的地址（call动作），但是由于func()是inline修饰的，所以编译器并不会把函数的地址放入符号表，所以就会出现链接错误
如果函数用inline属性修饰，那么编译器统一不会把该函数的信息放到符号表
所以内联函数一般是在.h中直接定义的，或者在需要调用的本.cpp文件中定义
二、auto关键字
auto用来干啥
在C语言中，auto是用来修饰局部变量的，意味着该变量在该代码块内要有效，出代码块自动销毁
但是在C++中，有了新的用法：自动推导变量类型
int a = 10;
auto b = a; //自动推导b的类型为a的类型（整形）
auto c = 'c';//自动推导c的类型为字符型
auto sum = Add(a,b);//自动推导sum的类型为函数的返回值类型
/* 分别打印变量类型的名字 --- typeid()*/
cout<<typeid(b).name<<endl;
cout<<typeid(c).name<<endl;
cout<<typeid(sum).name<<endl;
当然auto的使用场景不限于此
auto的使用场景
基于范围的for循环
通常在写for循环的时候，需要我们自己标注好循环的范围
但是有时会犯错误，C++因此引入了范围for循环
for循环后的括号由冒号：分为两部分：第一部分是范围内用于迭代的变量， 第二部分则表示被迭代的范围.
int arr[]={1,2,3,,4,5,6,7,8};
for(auto e : arr)
{
cout<<e<<" ";
}
//自动依次取 arr的元素赋值给e
这样，不管数组元素的类型是什么，都会自动打印每一个元素
注意：范围for循环什么时候不能用
for循环的迭代返回必须是确定的，对于数组而言，就是第一个元素到最后一个元素
比如：
void test(int arr[])
{
for(int e:arr)
{
cout<<e<<" ";
}
}
// 数组形参其实就是首元素地址，而非整个数组
// 所以此时迭代找不到范围，出错！
自动推导变量类型
如果变量的类型特别长，那么写起来就很麻烦
这时候就体现出来auto的价值了
举个例子：
std::map<std::string,std::string>::iterator it = dict.begin()
就可以替换成：auto it = dict.begin()
auto的使用细节
- auto与指针和引用结合起来使用
auto与指针:auto与auto*一样
auto与引用:auto&
int x = 10;
auto a = &x;//自动推导a是int*
auto* b = &a;//auto* 表明b是一个指针，这时候右边必须传指针
auto& c = x;// 表明c是一个引用（别名），自动推导c的类型为int
这样就可以利用范围for来修改数组元素了
//利用引用，e就是每一次该元素的别名，利用别名进行修改元素
for(auto& e : arr)
{
e++;//每个元素++
}
*********************************************
//利用指针可以吗？--不可以！
for(auto* e:arr)
{
*e?
}
/* 注意：范围for是不可以用指针的
因为范围for是把数组的每一个元素传递
只能用传值接受和传引用接收，指针不识别*/
- 在同一行定义多个变量
最好不用auto一行定义多个，如果多个变量的类型存在不同，是无法识别的！
当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对 第一个类型进行推导，然后用推导出来的类型定义其他变量
auto a = 10, b = 30; // 这样可以识别
auto c = 10, d = 30.0;// 一个是int，一个是double。无法识别
注意
使用auto定义变量时必须对其进行初始化，因为在编译阶段，编译器就会根据后面初始化给的值来推导出auto的类型。并在编译期间就会把auto替换为变量的实际类型
auto不能使用的场景
- auto不能作为函数参数
//此时代码编译会出错，auto不能作为形参类型
//因为编译器无法推导出形参的实际类型
void test(auto a)
{
/***/
}
准确点来说，函数调用需要开辟栈帧。而编译器给函数开辟栈帧之前就已经根据形参、函数体里的开辟的空间的大小算好要开辟的栈帧大小了。而auto的形参对于编译器来说，不知道要开辟多大的空间。所以会报错
- auto不用来声明数组
void test()
{
int a[]={1,2,3};
auto b[]={4,5,6};
//编译器无法自动推导数组的类型
}
三、空指针nullptr
C语言中，空指针是NULL，是一个宏
在C++中NULL似乎也可以用，但是C++中的NULL其实是有问题的。C++大佬在设计的时候可能没有考虑全面
在C++98中，字面常量0既可以是一个整形数字，也可以是无类型的指针(void*)常量
但是编译器默认情况下 将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转(void *)0。
看一下在C++中NULL的定义
#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif
可以看到，NULL在C++中其实就是 0
在C语言中才是(void*)0，即空指针
所以C++如果用NULL做空指针，就会出现这种情况
//f函数构成函数重载
void f(int)
{
cout<<"f(int)"<<endl;
}
void f(int*)
{
cout<<"f(int*)"<<endl;
}
int main()
{
int* p = NULL;
f(NULL);//调用 f(int)
f(0);// 调用f(int)
f(p);// 调用f(int*)
/* 显然，f(NULL)我们本想调用 f(int*)
但是却调用成了 f(int) */
return 0;
}
所以为了补C++的坑，C++11中引入了nullptr作为空指针
注意
- 在使用
nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的 - C++11中，
sizeof(nullptr)与sizeof((void*)0)所占的字节数相同