c++入门介绍下 （引用，内敛函数，auto关键字，基于范围for循环， 指针空值nullptr）

 

 看这篇文章前，请先看一下c++入门介绍上；

这是阿鲤对c++基础知识所学现在分享出来；若有误请慷慨指教 

阿鲤将按照以下顺序进行介绍

一：引用

二：内敛函数

三：auto关键字

四：基于范围for循环

五： 指针空值nullptr

---

一：引用：

1.1：引用的概念

引用不是新定义一个变量，而是给已存在的变量去一个别名，编译器也不会为引用变量而开辟空间，它和它引用的变量共用一块内存空间，就好比把猫叫了一个咪咪。

类型& 引用变量名（对象名） =  引用实体；

int main()
{
	int a = 10; //引用实体
	int& ra = a; //引用
}

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

 

1.2：引用的特性

1. 引用在定义时必须初始化

2. 一个变量可以有多个引用

3. 引用一旦引用一个实体，再不能引用其他实体 ，改变后会改变

 

 

1.3：常引用

在对常数进行引用时，必须加const不然会出错

 

 1.4：引用的使用场景

1：引用做参数

#include<iostream>
using namespace std;

void Swap(int& left, int& right)
{
	int tmp = left;
	left = right;
	right = tmp;
}
int main()
{
	int a = 5;
	int b = 6;
	cout << "a = " << a << " b = " << b << endl;
	Swap(a, b);
	cout << "a = " << a << " b = " << b << endl;
	system("pause");
	return 0;
}

输出结果：

大家可以看到，经过引用，a,b两个值交换了；这就说明了引用就是a，b的本身，只是换了一个名字罢了；他们是共用一块内存空间的。

2：引用做返回值

#include<iostream>
using namespace std;

int& Add(int& a)
{
	return a += 10;
}

int main()
{
	int a = 10;
	cout << "a = " << Add(a) << endl;
	system("pause");
	return 0;

输出结果：

注意：如果函数返回时，离开函数作用域后，其栈上空间已经还给系统，因此不能用栈上的空间返回。如果以引用类型返回，返回值的生命周期必须不受函数的限制 (即比函数生命周期长）。

 

1.5：引用使用效率的对比

1：引用做参数和非引用做参数效率对比：

首先请看下面的例子：

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

struct A
{
	int a[10000];
};

void Test1(A a) 
{}
void Test2(A& ra)
{}

int main()
{
	A a = {0};
	int begin1 = clock();
	for (int i = 0; i < 100000; i++)
	{
		Test1(a);
	}
	int end1 = clock();
	int begin2 = clock();
	for (int i = 0; i < 100000; i++)
	{
		Test2(a);
	}
	int end2 = clock();
	cout << "以值作为函数参数所消耗的时间 = " << end1 - begin1 << endl;
	cout << "以引用作为函数参数所消耗的时间 = " << end2 - begin2 << endl;
	system("pause");
	return 0;
}

输出结果：

有上述例子可以看出，引用的效率直接比传值快了125倍；

2：引用返回值和值做返回值效率对比：

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

struct A
{
	int a[10000];
};
A a;
A Test1() 
{
	return a;
}
A& Test2()
{
	return a;
}

int main()
{
	int begin1 = clock();
	for (int i = 0; i < 100000; i++)
	{
		Test1();
	}
	int end1 = clock();
	int begin2 = clock();
	for (int i = 0; i < 100000; i++)
	{
		Test2();
	}
	int end2 = clock();
	cout << "以值作为函数返回值所消耗的时间 = " << end1 - begin1 << endl;
	cout << "以引用作为函数返回值所消耗的时间 = " << end2 - begin2 << endl;
	system("pause");
	return 0;
}

输出结果：

有上述例子可以看出，引用的效率直接比传值快了好多倍；

那么为什么以值和引用的效率差距这么大呢？

这是因为在以值作为函数返回值和函数参数时，其并不是直接返回而是需要在栈上开辟一块内存空间，这样效率就会低很多；而传引用，就是传本身不需要开辟空间，效率自然也就上去了。

 

1.6：引用和指针的区别

首先请看下面一段代码

#include<iostream>
using namespace std;

int main()
{
	int a = 10;
	int& ra = a;
	cout << "&a = " << &a << endl;
	cout << "&ra = " << &ra << endl;+
	system("pause");
	return 0;
}

输出结果：

由上面例子我们可以看出，引用是没有独立空间的，引用就是实体的别名；

引用的底层实现：

引用的底层实现是通过指针来实现的，下面例子中的ra和pa的作用是相同的。

#include<iostream>
using namespace std;

int main()
{
	int a = 10;
	int& ra = a;
	ra = 20;
	int *pa = &a;
	*pa = 20;
}

我们来看一下ra和pa的汇编代码

由此我们可以看出，ra就是通过指针来实现的；（汇编代码相同）；

 

1.7：引用总结

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

 

二：内敛函数

2.1：内联函数的概念

以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数压栈的开销，内联函数可以提升程序运行的效率。

请看下面例子：

#include<iostream>
using namespace std;

int Add1(int a, int b)
{
	return a+b;
}

inline int Add2(int a, int b)
{
	return a + b;
}

int main()
{
	int a = 1;
	int b = 2;
	Add1(a, b);
	Add2(a, b);
	return 0;
}

现在我们看这段代码的汇编；

看到汇编语言大家会发现，Add1(没有被inline修饰)，所以其有call 而被修饰了的Add2就没有call了，直接被展开了。

 

2.2：内联函数的特性

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

 

2.3：与内敛函数有关的面试题

宏的优缺点？
优点：
    1.增强代码的复用性。
    2.提高性能。
缺点：
    1.不方便调试宏。（因为预编译阶段进行了替换）
    2.导致代码可读性差，可维护性差，容易误用。
    3.没有类型安全的检查 。
C++有哪些技术替代宏？
    1. 常量定义 换用const
    2. 函数定义 换用内联函数

 

三：auto关键字

3.1：auto概念：

在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，但遗憾的是一直没有人
去使用它，大家可思考下为什么？
C++11中，标准委员会赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指
示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得

请看下面例子

#include<iostream>
using namespace std;
int main()
{
	auto a = 10;//int类型
	auto c = 'a';//char类型
	auto p = &a;//指针类型
	auto* ptr = &a;//指针类型
	auto &rra = a;//引用类型

	cout << typeid(a).name() << endl;//typeid 推测类型函数
	cout << typeid(c).name() << endl;
	cout << typeid(p).name() << endl;
	cout << typeid(ptr).name() << endl;
	cout << typeid(rra).name() << endl;
	system("pause");
	return 0;
}

输出结果：

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

3.2：auto的使用规则

1：由上述例子可以看出，auto定义指针时，auto 和 auto*是没有区别的。但是使用auto类型定义引用时，必须加&即&auto

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

3.3：auto不能推倒的场景

1：auto不能作为函数参数

2：auto不能来声明数组

3. 为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法

5. auto不能定义类的非静态成员变量

 

四：基于范围for循环

4.1：概念：

对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此C++11中引
入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二
部分则表示被迭代的范围

例子：

#include<iostream>
#include<typeinfo>
using namespace std;

int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8 };
	for (int e : arr)
	{
		cout << e << endl;
	}
	system("pause");
	return 0;
}

结果：

和其他类型的for循环一样，continue和break在这依旧适用。

4.2：使用条件：

1：for循环迭代的范围必须是确定的
对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供begin和end的方法，
begin和end就是for循环迭代的范围

2：2. 迭代的对象要实现++和--的操作。

 

五： 指针空值nullptr

学过c的都知道c里有一个NULL，是用来表示空的，但是NULL的本质还是零，以下是c++中队NULL的定义；

我们可以看到，NULL是被0所替换出来的，所以其本质是0，这就会在为我们写代码时，带来二义性，造成麻烦；如下

#include<iostream>
#include<typeinfo>
using namespace std;

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

输出结果：

我们的本意是想要通过f(NULL)来调用int*函数，但是因为NULL的二义性，使我们最终调用了int函数，所以我们想要调用int*函数，就必须使用int*队NULL进行强制转化；

为了消除这种二义性c++11给出了新的nullptr来定义空指针，但是为了兼容c并没有取消NULL；下面是nullptr的定义

注意：
1. 在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的。
2. 在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。
3. 为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。