[C++知识库]【C++】基础语法2

一、引用

1.概念

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。

用法：类型& 引用变量名(对象名) = 引用实体

如下面的代码

代码如下（示例）：

int main()
{
	int a = 0;
	int& b = a;//b是a的引用
	int& c = a;//c是a的引用
	cout << &a << endl;
	cout << &b << endl;
	cout << &c << endl;
	cout << endl;

	c = 2;//若改为b = 2;或a = 2;结果相同
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;
	cout << endl;
	return 0;
}

运行结果如下：

运行后可以看到，a、b、c三个变量的地址一样，说明他们所在的内存空间相同。由此可知，对a、b、c任一变量的修改都会影响其它两个变量的值。

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

2. 引用特性

（1）引用在定义时必须初始化。
（2）一个变量可以有多个引用。
（3）一旦引用一个实体就不能再引用其他实体。

代码如下（示例）：

int main()
{
	int a = 0;
	int& ra;//编译出错，因为在定义时没有初始化
	
	//b、c都是a的引用
	int& b = a;
	int& c = a;
	
	int d = 2;
	c = d;
	//这样写并不是将c变成d的引用，而是把d的值赋给c
	//由于c是a的引用，也就相当于将d的值赋给a
	
	return 0;
}

3.常引用

由于被const修饰的变量只能使用而不能修改（即只读），这里在引用时会出现一些情况

代码如下（示例）：

int main()
{
	const int a = 10;//只读变量
	int& ra = a; //该语句编译时会出错，因为a是只读的变量，但ra作为a的引用确可读可写（权限变大）
	const int& ra = a;//正确
	
	int b = 10;//可读可写
	const int& b = 10;//只读，正确（权限变小）
	return 0;
}

3.引用的使用场景

（1）做参数

代码如下（示例）：

void Swap(int& x, int& y)
{
	int temp = x;
	x = y;
	y = temp;
}

int main()
{
	int a = 10;
	int b = 20;
	cout << a << " " << b << endl;
	Swap(a, b);
	cout << a << " " << b << endl;
	return 0;
}

上面的代码中调用函数Swap时x是a的引用，这两个变量代表同一块内存空间，对x的修改就是对a的修改，y和b同理。所以不需要使用指针就可以完成变量内容的交换。

当参数或返回值是内存较大的变量或类时，传引用传参和传引用做返回值可以提高程序的效率。只要符合条件，尽量引用传参、做返回值。

（2）做返回值

不是在所有情况下引用都可以做返回值

下面是很简单的一个实现加法的程序。

代码如下（示例）：

int Add(int a, int b) //传值返回
{
	int c = a + b;

	return c;
}

int main()
{
	int ret = Add(1, 2);
	cout << "Add(1, 2) = " << ret << endl;
	return 0;
}

上面的Add函数传值返回，先把c的值给一个临时变量，接着ret接收这个临时变量的值，Add中return的其实是c的拷贝（一个int类型的临时变量）。

为什么要这样处理呢？

因为c可能是Add函数栈帧内的一个临时变量，返回时Add函数的栈帧已经销毁，c的值也变成了随机值，返回的值就不是原来c的值了。

代码如下（示例）：

//传引用返回
int& Add(int a, int b) 
{
	int c = a + b;
	return c;
}

int main()
{
	int& ret = Add(1, 2);
	cout << "Add(1, 2) = " << ret << endl;
	return 0;
}

上面的Add函数是传引用返回，ret就是函数中c的引用，但是这种写法是有问题的，因为Add调用结束以后c被销毁，再访问ret（相当于访问c）是非法的，得到的结果是不确定的。

注意：如果函数返回时，出了函数作用域，如果返回对象还未还给系统，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。

代码如下（示例）：

int& Add(int a, int b) 
{
	//c是静态变量，储存在静态区且只在第一次运行的时候初始化。函数栈帧的创建与销毁不会影响c
	static int c = a + b;
	return c;
}
int main()
{
	int& ret = Add(1, 2);//ret = 3
	//调用Add(1, 2)后c的值被初始化为3，不会再改变
	Add(3, 4);
	cout << "Add(3, 4) = " << ret << endl;//输出Add(3, 4) = 3
	return 0;
}

（4）引用和指针的区别

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

二、内联函数

1.概念

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

代码如下（示例）：

int Add(int a, int b) 
{
	int c = a + b;

	return c;
}
int main()
{
	int ret = Add(1, 2);
	return 0;
}

这段代码在反汇编下查看时，很明显看到程序调用（call）Add函数，如果Add函数多次调用，频繁地call会使程序效率下降。

而在Add函数前加上inline使其成为内联函数后再次运行。

代码如下（示例）：

inline int Add(int a, int b) 
{
	int c = a + b;

	return c;
}
int main()
{
	int ret = Add(1, 2);
	return 0;
}

查看反汇编，很明显反汇编代码减少了，同时没有出现call Add，这就能够提升程序的效率。

2.特性

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

3.与#define的区别

C语言为了避免简短的函数建立栈帧带来性能的消耗，提供宏，宏在预处理阶段展开，那么既然C语言已经解决了这个问题，为什么C++还要提供内联函数呢？

宏的优点：增强代码的复用性、提高性能。
缺点：
（1）不方便调试。（因为预编译阶段进行了替换）
（2）代码可读性差，可维护性差，容易误用。
（3）没有类型安全的检查 。

所以C++推荐把频繁调用的小函数定义成内联函数，在调用的地方展开时没有栈帧的开销。

三、auto关键字（C++11）

1.概念

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

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

代码如下（示例）：

double test()
{
	return 10;
}

int main()
{
	int a = 10;
	auto b = a;//类型声明为auto，编译器可以自动根据a的类型推导b的类型
	auto c = 'a';
	auto d = test();

	cout << typeid(b).name() << endl;
	cout << typeid(c).name() << endl;
	cout << typeid(d).name() << endl;

	return 0;
}

运行结果如下

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

2.使用注意事项

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

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

代码如下（示例）：

int main()
{
	int x = 10;
	auto a = &x;
	auto* b = &x;
	auto& c = x;

	cout << typeid(a).name() << endl;
	cout << typeid(b).name() << endl;
	cout << typeid(c).name() << endl;
	return 0;
}

运行结果如下

（2）在同一行定义多个变量

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

auto a = 1, b = 2;//正确
auto c = 10, d = 6.5;//编译不通过，因为c和d的类型不同

（3）auto不能使用的场景

auto不能作为函数的形参且auto不能直接用来声明数组

除此之外，下面两种写法也是不合法的：

auto e;//不合法，使用auto变量时必须对其初始化
auto m = (auto*)malloc(sizeof(auto));//不合法

auto在实际中最常见的优势用法就是跟以后会讲到的C++11提供的新式for循环等进行配合使用。（下面会提到）

四、范围for（C++11）

1.语法

遍历数组更加简单，自动遍历。

代码如下（示例）：

int main()
{
	int arr[] = { 1, 2, 3, 4, 5 };
	for (auto e : arr)
		cout << e << " ";
	cout << endl << endl;
	for (auto ee : arr)
	{
		ee *= 2;//注意这里不会改变arr数组内的值
		cout << ee << " ";
	}
	cout << endl;
	return 0;
}

运行结果如下

2. 范围for的使用条件

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

（2）对象的迭代器要能够实现++和==的操作。

（关于迭代器之后会提到）

五、nullptr（C++11）

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

感谢阅读，如有错误请批评指正