专栏放在【C++知识总结】，会持续更新，期待支持?

内联函数

宏与内联函数

我们在C语言阶段就学习了关键字#define 用来定义宏（宏函数、宏常量），然后在预处理阶段会实现宏的替换，这样的话不仅大大的提高了代码的复用性（不会把代码写死，更改起来方便），而且还提高了整体的性能。但是，宏替换也存在着一些缺点：

宏的缺点：

不能调试，因为宏替换是在预处理阶段完成的 不够安全，没有类型安全的检查（因为都是符号） 使用起来会比较复杂，可读性差

就比如说，我们用宏来实现一个简单的加法操作，就可能会出现各种乱七八糟的错误：

#include<iostream>
using namespace std;
//宏缺点： 1、不能调试
       // 2、没有类型安全的检查 
       // 3、可读性差，有些场景比较复杂

#define ADD(A,B) ((A)+(B))

int main()
{
    cout << ADD(1, 3)*3 << endl;//12
    //预处理阶段实现宏的替换：cout << ((1)+(3))*3 << endl;
    return 0;
}
//但是很容易写错:
//#define ADD(int a,int b) a+b  error
//#define ADD(a,b) (a+b)        error
//#define ADD(a,b) (a)+(b)      error
//#define ADD(a,b) ((a)+(b));   error

而C++针对宏存在的这些缺点，给出了以下应对方法：

1. 用const enum来定义常量
2. 用内联函数来替换短小宏函数的定义

内联函数的概念

函数前面用关键字inline来修饰的函数，就叫内联函数，编译时C++编译器会在调用内联函数的地方将指令展开，没有函数调用建立栈帧的开销，从而提升程序运行的效率。

内联函数的特性

空间换时间

内联函数 vs 函数

我们可以针对一段简单的代码，来查看两者的反汇编，测试一下内联函数究竟会不会提升效率，不过在此之前需要进行一些调整，在debug版本下，想要观察内联函数指令的展开，需要进行如下设置：

接下来我们通过一段简单代码来进行对比：

因此，我们可以很直观的看到，内联函数是在编译阶段，直接将指令展开，并没有调用函数，从而开辟栈帧，因此会提升程序的运行效率。

但是，这样会带来一种后果，就是虽然程序的效率得到提高，但是最终形成的可执行程序的大小，会变大，因为内联函数会在编译阶段将指令展开，假如一个程序有1000个地方用到这个函数，也就意味着会展开1000次指令（假如这一个内联函数的实现需要上百行指令，则每一次使用该函数都会展开上百行），是一个倍数关系。而普通的函数在调用函数时，用的都是同一个函数，只不过每一次调用，都加上了cal指令，进行跳转到该函数，因此这是一个相加的关系。（内联函数：空间换时间）

因此，内联函数会使程序的效率得到提高（不用额外开辟栈帧），但是也会导致生成的目标文件的大小会变大。不过有些编译器会忽略掉内联的请求（有些内联函数编译器并不会进行展开），因此对于一些规模较小且频繁使用的函数，我们才使用内联函数。

内联函数不建议声明和定义分离

分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到，编译器会报错

总结

内联函数用来弥补宏替换存在的缺陷，在编译阶段会将指令展开，不会开辟额外栈帧，提高程序效率的同时，也会使目标文件变大，适用于规模小，调用频繁的函数，另外内联函数的声明与定义不可分离，会导致链接错误。

auto关键字

用法

就不多做一些背景介绍了，直接谈谈它的用法，auto的作用：用来进行自动推导变量的类型并进行替换，具体是什么意思呢？看下面两个代码：

int a=0;//a的类型为int
auto b=a;//auto进行自动推导，由于b=a，a的类型为int，所以b的类型就会被推到成int

我们可以通过typeid(变量).name()来查看该变量的类型，我们可以发现，b的类型确实就是a的类型

因此，假如一个变量的类型名称过于长的时候，如果后面有和它同类型的变量，我们为了避免输入错误，减少麻烦，可以直接用auto来自动推导，当然，也可以用typedef用来类型重命名，不过auto显然更加好用。

auto使用规则

首先auto定义的变量必须初始化

因为编译阶段编译器需要根据初始化表达式来推导auto的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为变量实际的类型。

auto b;//error,必须初始化
auto c=1;//1是int,所以c的类型是int
//typeid(c).name()//int

auto与指针和引用结合起来使用

用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&

int main()
{
    int x = 10;
    auto a = &x;
    auto* b = &x;
    //在与指针使用时，auto与auto*都可以，没有区别
    auto& c = x;
    //假如是引用场景下，后面必须加上&
    cout << typeid(a).name() << endl;//int*
    cout << typeid(b).name() << endl;//int*
    cout << typeid(c).name() << endl;//int

    return 0;
}

在同一行定义多个变量

当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。

    auto a = 1, b = 2;//auto先对a推导，为int，然后用推导出来的类型来定义b，就是int b=2
    auto c = 3, d = 3.5;//error  因为c是int，所以就会用int来定义d，但是d的类型为double，所以error

auto禁用场景

不能作为函数的参数

// 此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导
void TestAuto(auto a)
{}

不能直接用来声明数组

auto与新式for循环

auto在实际中最常见的优势用法就是跟C++11提供的新式for循环，还有lambda表达式等进行配合使用。这里先来讲for循环

以前我们用for循环来对数组的内容进行修改并打印时，都是这么用的：

    int arr[] = { 1,2,3,4,5};
    for (int i = 0; i < sizeof(arr)/sizeof(arr[0]); i++)
    {
        arr[i] *= 2;//数组内容扩大两倍
    }
    //打印
    for (int i = 0; i <sizeof(arr)/sizeof(arr[0]); i++)
    {
        cout << arr[i] << " ";//2 4 6 8 10
    }

对于这么一个数组，我们知道它的范围，然而我们在书写for循环时还要再进行书写一下，这种行为就显得比较多余，并且有时还会因为边界问题而出错，因此，在C++11中有这么一种新的for循环，括号里面由：分为两部分。第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。

如下：会显得简洁很多

    int arr[] = { 1,2,3,4,5 };
    for (auto& a : arr)
    {
        a *= 2;
        //a这里auto与&结合，说明该变量是数组元素的“别名”，范围在arr数组内
    }
    for (auto a: arr)
    {
        cout << a <<" ";//这里的a表示着该数组内的元素从头遍历到结束
        //2 4 6 8 10
    }

这里需要注意的是，使用这种新式for循环，必须保证被迭代的范围是确定的！

NULL与nullptr

NULL实际是一个宏，在传统的C头文件(stddef.h)中，可以看到如下代码：

#ifndef NULL #ifdef __cplusplus #define NULL 0 #else #define NULL ((void *)0) #endif #endif

这段代码的意思就是说，在c++环境下，定义NULL表示0，这里的0就是int类型的数字0，其余环境（C语言）下表示空指针（将0强制类型转化为了void*）我们在c++下进行验证一下

因此，在C++中通常会使用nullptr来表示空指针，大小在32位机器下为4字节

end.

生活原本沉闷，但跑起来就会有风！?