C++基础语法（下）

引用

引用概念

引用不是定义一个新的变量，而是给已有的变量取一个别名，对别名的操作就是对引用对象的操作
语法：类型& 引用变量名=引用对象变量名

int main()
{
	int a = 1;
	int& b = a;
	b = 3;
	return 0;
}

引用不是重新开辟空间，它与引用对象公用同一块空间

我们仔细观察图中类型一列，发现&b的类型是int*，说明引用的类型就是引用对象的类型。

引用特性

1、引用在定义时必须初始化
2、一个变量可以有多个引用，当引用对象一旦确定便不可更改

int main()
{
	int a = 0;
	int p = 1;
	int& rp = p;//int& rp;会报错
	int& rp1 = p;
	//rp=a;会报错
}

3、常引用
在引用时，一定要注意引用对象的类型和引用权限

int main()
{
	const int a = 0;
	const int& ra = a;//如果不加const就放大权限了，编译不过
	double b = 1.33;
	double& rb = b;
	const int& rbi = b;//如果不加const就会用出现下图错误
	//int& rb1 = b;
	return 0;
}

使用场景

1、作为函数参数(类似与传地址)

#include<iostream>
void swap(int& a, int& b)
{
	int tmp = a;
	a = b;
	b = tmp;
}
int main()
{
	int a = 12;
	int b = 3;
	std::cout << "a=" << a << std::endl << "b=" << b << std::endl;
	swap(a, b);
	std::cout << "a=" << a << std::endl << "b=" << b << std::endl;
	return 0;
}

相比与传地址不用解引用操作，更加方便

2、作为函数返回值
大家想想下面这段代码会输出什么？

#include<iostream>
int& Add(int a, int b)
{
	int c = a + b;
	return c;
}
int main()
{
	int& ret = Add(1, 2);
	std::cout << ret << std::endl;
	Add(5, 7);
	std::cout << ret << std::endl;
	return 0;
}

当初我认为是两个随机值。因为ret是返回值c的别名，而c在出作用域时已经被系统销毁了，但是ret的地址还是c的地址，所以应该是随机值。但我万万没想到虽然c被销毁了，但是这个地址上的值并没被清空，所以还是3。
正确答案：3，12。你答对了吗？
所以，当返回值出了函数作用域没被销毁时(如malloc等动态开辟的空间)，我们才能用传引用作为返回值，而返回值会被销毁时我们就必须用传值返回。

传值、传引用的效率比较

#include<iostream>
using namespace std;
#include <time.h>
struct A
{
	int a[10000]; 
};
void TestFunc1(A a){}
void TestFunc2(A& a){}
void TestRefAndValue()
{
	A a;
	// 以值作为函数参数
	size_t begin1 = clock();
	for (size_t i = 0; i < 10000; ++i)
		TestFunc1(a);
	size_t end1 = clock();
	// 以引用作为函数参数
	size_t begin2 = clock();
	for (size_t i = 0; i < 10000; ++i)
		TestFunc2(a);
	size_t end2 = clock();
	// 分别计算两个函数运行结束后的时间
	cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
	cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
	int main()
{
	TestRefAndValue();
	return 0;
}
}

我们可以看出确实传引用效率要更高，因为传值会开辟一块空间用来拷贝返回值的数据，一旦数据的量变大时，传值效率就会很低，所以在数据量大时，我们最好传引用，如果函数的目的不会改变原函数变量的值时，我们最好用const将其保护起来。

传值和传引用作为返回值的效果与传参类似，感兴趣的朋友可以去试一试。

引用和指针的区别

经过上面的学习，我们今天看出引用和指针的效果十分相似，那它们有什么差异呢？
1、在语法概念上引用是对象的别名，与引用对象共用一个地址，而指针会开辟地址来存储对象的地址

#include<iostream>
int main()
{
	int a = 9;
	int& ra = a;
	int* pa = &a;
	return 0;
}

我们看底层实现时，会发现引用就是用指针实现的，实际上它是开了空间的。

2、指针需要接引用操作，而引用不需要
3、引用必须初始化，指针不必。
4、引用只能有一个对象，而指针可以是一个海王
5、没有NULL引用，而有空指针
6、有多级指针，但没多级引用
7、使用引用比指针更加安全
ps：不用死记硬背，最好通过理解它们两的本质来看问题。

内联函数

概念

用inline关键词修饰的函数叫做内联函数，内联函数在被调用时会在被调用出展开，避免了函数压栈的开销，适合简单并多次使用的函数，提高程序的效率。
因为编译器在debug版不设置内联函数就不会展开，下面给出vs2013的设置方式
1、

2、

3、

那我们来看看效果对比
1、不加inline修饰

#include<iostream>
int Add(int a, int b)
{
	return a + b;
}
int main()
{
	int ret = Add(1, 2);
	return 0;
}

进行了调用函数的操作

2、使用内联函数

#include<iostream>
inline int Add(int a, int b)
{
	return a + b;
}
int main()
{
	int ret = Add(1, 2);
	return 0;
}

没有调用函数，直接在调用出展开。

特性

1、是一种用空间换时间的操作，适合简单并在程序中多次使用的子函数，如出现了递归和循环等场景，不宜使用内联函数。
2、不能将内联函数的定义和声明分开（会出现链接错误），因为内联函数会被展开，函数地址就没了，链接就会找不到。

面试题：
宏的缺点和优点有哪些？
优点：
1、提高代码复用性
2、提高性能（类似与内联函数）
缺点：
1、不能调试
2、可读性和可维护性差，容易误用
3、没有类型安全检查
C++有哪些技术可以代替宏？
1、常量定义使用const修饰
2、函数定义使用内联函数

auto关键字（C++11）

使用规则

1、auto与指针、引用
auto声明指针类型时，auto和auto*没有区别，而声明引用时，必须使用auto&。

#include<iostream>
using namespace std;
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;
	*a = 20;
	*b = 30;
	c = 40;
	return 0;
}

2、一行定义多个变量时，变量类型必须一致，不然会报错。

auto不能使用的情况

1、不能作为函数的参数
2、不能直接用来声明数组

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

for的语法

在C++98中遍历一个数组，需要我们来规定它的范围，如

#include<iostream>
using namespace std;
int main()
{
	int arr[] = { 1, 2, 3, 4, 5 };
	int i = 0;
	for (i = 0; i < (sizeof(arr) / sizeof(arr[0]); i++)
	{
		cout << arr[i] << endl;
	}
	return 0;
}

对于一个有范围的集合而言，由程序员来说明范围是多余的和不安全的。
因此C++11中引入了基于范围的for循环。
for括号中由:隔开，前一部分是范围内迭代的变量，后一部分是迭代的范围

#include<iostream>
using namespace std;
int main()
{
	int arr[] = { 1, 2, 3, 4, 5 };
	int i = 0;
	//for (i = 0; i < (sizeof(arr) / sizeof(arr[0]); i++)
	//{
	//	cout << arr[i] << endl;
	//}
	for (auto& e : arr)
		e *= 2;
	for (auto e : arr)
		cout << e << " ";
	return 0;
}

是不是很方便啊。

空指针nullptr

nullptr的本质

在C++11中被如此定义：（void*）0
而NULL被定义为：0
使用NULL就会导致一些错误，如：

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

是不是很致命啊。而使用nullptr就不会出现这种情况了。

各位看官来个三连支持一下，不要下次一定。😄