C++之入门之引用，内联函数

一、引用

1、引用的概念

在C++中，引用的本质其实就是给一个已经存在的变量”起别名“。也就是说，引用与它所引用的对象共用一块空间。（同一块空间的多个名字）

就比如说，李逵又叫黑旋风，而黑旋风就是指李逵本人，只是名字换了而已。

int a = 20;

int* pa = &a;	//指针
int& ra = a;	//引用

2、引用的特性 

1、引用在使用时必须初始化

2、一个变量可以有多个引用，但一个引用只能有一个实体对象

 可以看出：地址相同，abcd共用一个空间。

引用还有几点需要注意：1、引用无法改变指向

char& ra = a;
char& ra = b;	//错误，引用一旦确立后，就无法再改变其指向
ra = b;	//这个没问题，实际结果为 a = 'B' 即将 b 的内容赋值给 a

2、引用不存在多级引用

char& ra = a;
char&& b = ra;	//非法，不存在多级引用
char& b = ra;	//合法，实际结果为 char& b = a;

三、常引用

指针和引用在赋值或者初始化时，权限可以被缩小或者保持，但不可进行修改。

来看如下代码：

    // 权限放大(error)
    //const int c = 2;//const 修饰的常量不可以进行修改，可以理解只具有读的属性，不具有写的属性，而d可以修改，所以权限被放大
    //int& d = c;//这里正确写法应为const int& d=c;
 
    //const int* p1 = NULL;
    //int* p2 = p1;//同上，前面加个const即可,const int* p2=p1; (√)
 
    // 权限保持
    const int c = 2;
    const int& d = c;
 
    const int* p1 =NULL;
    const int* p2 = p1;
 
    // 权限缩小
    int x = 1;//x可以进行修改，可以理解为具有读和写的属性，而x是const修饰的，只具有读的属性，权限缩小了
    const int& y = x;
 
    int* p3 = NULL;
    const int* p4 = p3;//同上

引用主要有以下的使用场景：

1、做参数：

void swap(int& ra, int& rb)
{
	//有了引用之后，不需要再解引用，也能达到指针的效果
	int tmp = ra;
	ra = rb;
	rb = tmp;
}

 2、做返回值：

//返回值
int& Test()
{
    static int a = 10;
    a++;
    return a;//也会产生临时变量，但是临时变量的类型是int& 也就是a的别名，即临时变量就是返回的a，减少了拷贝操作
}
int main()
{
    int ret = Test();
    return 0;
}

这就是引用返回，即在返回类型前面加上&，虽然也需要借助临时变量的存在，但是由于临时变量的类型为int& ,即临时变量就是a，所以就减少了临时变量的拷贝工作，会使效率得到提升。当引用做返回值时，接收到的变量就是函数返回时的本体，就是变量ret。

不过需要注意的是：

 这段代码是错误的，原因是：val是函数 func 中的局部变量，当函数结束后，变量就被销毁了，此时可能得到正确的结果(编译器未清理)，也可能得到错误的结果（编译器已清理）。

这就告诫我们如果是局部变量就不适合使用引用调用，而生命周期是较长的变量，适合使用引用返回，不需要创建临时变量。

二、内联函数

1、内联函数的概念

我们知道在创建函数的过程中：一个函数在开始调用时会建立函数栈帧，结束调用时会销毁函数栈帧，而函数栈帧的建立与销毁是有空间和时间上的开销的。

对于功能简单，而调用次数很多的函数来说，每次调用都重新开辟栈帧势必就会造成效率的降低，在C语言中们使用宏函数来解决这个问题：我们直接将 要调用的函数写成宏函数，这样使得程序在预处理阶段直接将调用的函数替换成相应的代码，从而不再建立函数栈帧。

比如交换函数代码：

#define Add(x,y) ((x)+(y))  //宏函数

宏定义除了复杂以外还有如下缺点：

1、不能进行调试，宏是直接进行替换的

2、没有类型的安全检查

 所谓内联函数就是在函数实现前加上 inline 修饰，此时函数会被编译器标记为内联函数。

//此时的 Add 函数就是一个内联函数
inline int Add(int x, int y)
{
	return x + y;
}

内联函数有如下特点：

• 在 Debug 模式下，函数不会进行替换，可以进行调试
• 在 Realse 模式下，函数会像宏函数一样展开，提高程序运行速度
• 内联函数弥补了宏函数的不足，同时吸收了宏函数速度快的优点

三、auto关键字

在代码的编写中，随着程序的越来越复杂，所用的类型也越来越复杂，所以我们就需要引入auto关键字。

1、auto功能

auto 关键字能直接识别目标变量类型，然后自动转换为相应类型

int a = 10;
int* b = &a;

auto aa = a;	//此时 aa 为 int
auto bb = b;	//此时 bb 为 int*

不过在以后的学习过程中会遇到名字很长的变量，这就要用到auto关键字了。

#include <string>
#include <map>
int main()
{
	std::map<std::string, std::string> a{ { "apple", "苹果" }, { "orange","橙子" },{"pear","梨"} };
	std::map<std::string, std::string>::iterator it = a.begin();
	while (it != m.end())
	{
		//....
	}
	return 0;
}

auto的功能还可以指定转化类型。

int a = 10;

auto* pa = a;	//指定 pa 为 int*
auto& ra = a;	//指定 pa 为 int&

不过要记住：

auto a = 1, b = 2.2;	//非法，类型不统一

这个定义变量是错误的。

四、基于范围的for循环

在C++中，我们有更简介的方法来使用for循环，不用向之前这么繁杂。就像Python中使用for循环方法类似，在一个范围里进行for循环的。

来看如下的代码：

void TestFor()
{
	int array[] = { 1,2,3,4,5 };

	//使用引用进行迭代--可以修改原数组
	for (auto& e : array)
		e *= 2;

	//使用局部变量进行迭代--不能修改原数组
	for (auto e : array)
		cout << e << " ";

	cout << endl;  //换行
}

int main() {
	TestFor();
}

 for循环后的括号被冒号分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。

 范围for的使用条件：1、范围大小必须确定 2、迭代对象要使用++，==的操作。