【初始C++】引用的概念及使用场景、引用与指针的区别、内联函数、类型推导关键字auto、范围for循环、指针空值nullptr

1.引用

1.1引用的概念

1.2引用的特性

1.3使用场景

1.4引用与指针的区别

2.内联函数

2.1内联函数的概念

2.2内联函数的特征

3.auto关键字（C++11）

4.基于范围的for循环（C++11）

5.指针空值nullptr（C++11）

1.引用

1.1引用的概念

引用不是新定义一个变量，而 是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空

间，它和它引用的变量 共用同一块内存空间。

引用的声明方法：类型& 引用变量名(对象名) = 引用实体；

看到 & 这个符号是否会觉得熟悉，在C语言中，我们用&来取变量的地址，还可以表示进行按位与操作，在C++中我们沿用了这两种表达方式，新增了引用。

区分使用&的三种情况：

&a ；表示取地址

a&b ；a,b进行按位与

int& b = a ;b是a的引用，即b是a的别名

可以给一个变量定义多个引用，即取多个别名，也可以给别名取别名。

    int a = 10;int& b = a;  //给a取别名int& c = a;  //给a取别名int& d = b;  //给b取别名

1.2引用的特性

（1)引用必须初始化

（2）一个变量可以有多个引用

（3）引用定以后不能改变指向

int& b = a;

b = c; //该操作是将c的值赋给a

引用的一个使用场景：

在学习引用之前，在交换两数的Swap函数中，传过去的参数是两数的地址，函数参数用指针接收，使用引用时参数写为类型& 别名

void Swap1(int* x,int* y)  //x,y是a,b的地址
{int tmp = *x;*x =*y;*y = tmp;
}
void Swap2(int& x, int& y) //x,y是a,b的别名
{int tmp = x;x = y;y = tmp;
}
int main()
{int a = 1;int b = 2;Swap1(&a,&b);Swap2(a,b);return 0;
}

既然能这样使用，那么引用能否替代指针？

不能完全替代，指针和引用的功能类似，C++的引用对指针使用比较复杂的场景进行一些替换，让代码更简单，不能完全替代的原因：引用定以后，不能改变指向。

1.3使用场景

（1）做参数

a、输出型参数

像下面这道题中的returnSize，就是一个输出型参数。

二叉树的前序遍历

b、如果对象比较大，减少拷贝，提高效率。

虽然指针也能达到目的，但是引用效率更高，更省时。

（2）做返回值

a、修改返回对象

b、减少拷贝、提高效率

以下代码是引用做返回值的形式吗？

代码（1）是传值返回，返回a的值用ret接收，因为a是局部变量，fun1函数结束，ret收到的值取决于函数栈帧销毁时对这块空间清不清零，如果清零就收到的返回值就是随机值；

代码（2）是引用返回，返回a的引用，但因为a仍是局部变量，与（1）相同，对这片空间清零的话ret收到的值就是随机值；

代码（3）中返回a的引用，ret也是a的引用，但出了作用域a的空间就被反还给操作系统，ret成了野引用，就找不到a了；

总结：如果返回变量出了函数作用域生命周期到了要销毁，就不能用引用返回

所以以上都不是。以上是传值返回和传引用返回的区别，前者是传返回值的拷贝，后者是传返回值的引用。

可以用引用返回的情况有：全局变量/静态变量/堆上变量等

int& func()
{static int a = 0;return a;
}
int main()
{int ret = func();cout << ret << endl;
}

1.4引用与指针的区别

语法上：

a、引用是别名，不需要开额外的空间；指针是地址，需要开辟空间存放地址

b、引用必须初始化，指针可以初始化也可以不初始化

c、引用不能改变指向，指针可以改变

d、引用相对更安全，没有空引用，但是有空指针。所以容易出现空指针，不容易出现空引用

e、在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数

f、有多级指针，没有多级引用

g、引用++是对所引用的实体增1，指针++是指针向后偏移一个类型的大小

h、指针需要显示解引用，引用编译器自己处理

用法和底层：

汇编层面上，没有引用，都是指针，引用在编译后也转换成指针了

2.内联函数

2.1内联函数的概念

每调用一次函数就建立一个栈帧，如果频繁调用就需要频繁建立栈帧，在C语言中，使用宏函数解决了这个问题。但是宏函数在书写时语法比较复杂不好控制，所以C++中引入了内联函数。

以 inline修饰的函数叫做内联函数， 编译时C++编译器会在 调用内联函数的地方展开，没有函数调

用建立栈帧的开销，内联函数提升程序运行的效率。

2.2内联函数的特征

（1）inline是一种以空间换时间的做法，如果编译器将函数当作内联函数处理，在编译阶段，会用函数体替换函数调用。（空间不是内存空间，是指编译好的可执行程序）缺点：可能会使目标文件变大，即发生代码膨胀；优点：减少了调用开销，提高程序运行效率。

（2）inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般将函数规模小的、不是递归的、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。

（3）inline不建议声明和定义分离，否则会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。

如果在头文件内定义一个函数，在多个文件包含该头文件，程序将会报错。报错信息如下：

这是因为在生成的code.o和test.o内都有函数定义，该函数地址进入符号表了，在链接时两文件的符号表需要合并，合并时发生存在两个一样的函数，便发生了链接错误。

链接错误的解决方法：

①声明与定义分离

这种方法是我们最常使用的一种，在头文件声明，其他文件定义。

②static修饰

如果不想将声明和定义分离，便可使用static修饰函数。static修饰函数是改变了函数的链接属性，语法上说是只在当前文件可见，从底层讲是该函数地址不会进入符号表，因此不会发生链接冲突。

③inline修饰

声明与定义不可分离，与静态修饰的原理类似。一般我们对小函数用inline修饰，大函数用static修饰。

3.auto关键字（C++11）

3.1引入

随着程序越来越复杂，程序用到的类型也越来越复杂，比如含义不明确、类型难拼写等。

#include<map>
#include<string>
int main()
{std::map<std::string, std::string>m{ {"apple","苹果"},{"orange","橘子"}};std::map<std::string, std::string>::iterator it = m.begin();//...return 0;
}

std::map<std::string, std::string>::iterator 是一个类型名，但是该类型太长了，写起来很麻烦，所以我们可以通过给它取别名来减少失误。

在C语言的学习中，我们使用typedef给类型取别名，比如添加 typedef std::map<std::string, std::string> Map 。

#include<map>
#include<string>
typedef  std::map<std::string, std::string> Map ；
int main()
{std::map<std::string, std::string>m{ {"apple","苹果"},{"orange","橘子"}}；Map::iterator it = m.begin();//...return 0;
}

那么在C++中，使用什么可以简化代码呢？由此我们引出了关键字auto。

写为：

auto it = m.begin();

3.2auto的含义

auto的作用是自动推导类型，在使用的时候必须初始化。

在早期的C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量。

C++11中，auto被赋予了新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推到而得。

#include<iostream>
using namespace std;
int main()
{int i = 1;auto j = i;cout << typeid(j). name() << endl;  //typeid用于打印参数类型auto p = &i;auto* ps = &j;cout << typeid(p).name() << endl;cout << typeid(ps).name() << endl;auto& k = j;cout << typeid(k).name() << endl;//auto m;    error C3531: “m”: 类型包含“auto”的符号必须具有初始值设定项return 0;
}

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

3.3auto的使用场景

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

通过前面例子可以看出用auto声明指针类型时使用 auto 和 auto* 没有区别，但在用auto声明引用类型时必须写为auto&。

3.3.2在同一行声明多个变量

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

void TestAuto()
{
auto a = 1, b = 2;
auto c = 3, d = 4.0;
}

报错如下：

3.4auto不能推导的场景

（是规定，记住就可以了）

①auto不能作函数的参数

②auto不能用来声明数组

③与新式for循环，lambad表达式等配合使用。

4.基于范围的for循环（C++11）

4.1引入

在C++98中，我们要遍历一个数组通常使用下面的方式进行：

void TestFor()
{int array[] = { 1,2,3,4,5 };for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)array[i] *= 2;for (int* p = array; p < array + sizeof(array) / sizeof(array[0]); ++p)cout << *p << endl;
}

遍历的范围是一个有限的集合，为了避免出错，在程序员使用时可以不必说明循环范围。因此在C++11中引入了基于范围的for循环。for循环后的括号由“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。

上述代码可修改成下面的形式，想想打印的结果是什么？

void TestFor()
{int array[] = { 1,2,3,4,5 };for (auto e : array)  //依次取数组中的值赋值给e，自动迭代，自动判断结束e *= 2;for (auto e : array)cout << e << " ";
}

结果是：1 2 3 4 5

不是已经执行 e *= 2 了吗，为什么打印出的结果还是原数值呢。因为只是将array[0]、arrary[1] 等的值赋给了变量e，e只是它的一份拷贝，并不会修改数组本身的值。要想修改数组的值，只需将变量声明为引用类型。

4.2范围for的使用条件

①for循环迭代的范围必须是确定的

像下面代码就是有问题的，因为循环迭代的范围不确定。（形参不能是数组，传过来的是指针）

void TestFor(int a[])
{for (auto& e : a)e *= 2;
}
int main()
{int arr[] = { 1,2,3 };TestFor(arr);return 0;
}

②迭代的对象要实现++和==的操作

5.指针空值nullptr（C++11）

请看以下代码，思考一下结果是什么

void f(int i)
{cout << "f(int)" << endl;
}
void f(int* i)
{cout << "f(int*)" << endl;
}
int main()
{f(0);f(NULL);
}

结果如下：

与你思考的结果一样吗？f(NULL)对应结果为什么不是f(int*)？

在C++98中NULL实际是一个宏，在stdio.h中可以看到以下代码

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

可以看出NULL被定义为字面常量0，或者被定义为无类型指针(void*)的常量。从而出现了上面的问题。

所以要想在C++中匹配第二个函数时应该将NULL强转成指针类型。

这样看来每次使用指针空值时需要强转，很不方便。在C++11中引入了一个关键字nullptr，用它来表示指针空值。

注意：

①使用nullptr表示指针空值时不需要包含头文件

②在C++11中，sizeof(nullptr) 与 sizeof((void*)0) 所占字节数相同

③为了提高代码健壮性，后续都建议使用nullptr表示指针空值