引用和指针的区别 内联函数 auto的使用细则 范围for

c++

引用和指针的区别

#include<iostream>
using namespace std;
int main()
{
	int a = 0;
	int* p1 = &a; //指针是要开空间的，在32位系统下是4个字节，64位是8个字节

	int& ref = a;   //引用是不用开空间的，它只是a的一个别名，它和a共用一个空间,但是引用是靠指针来实现的，所以引用的底层就是指针


	return 0;

看一看它们的汇编代码

你会发现：指针和引用在底层是一模一样的；
引用和指针的不同点:

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

内联函数

为啥c++要有内联函数？

为了弥补c语言宏的缺点

宏有哪些缺点

首先，宏分为两种：1.宏常量，2. 宏函数

//宏常量
#define N 10

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

缺点：

1. 容易出错，语法的坑有很多
2. 不能调试，（在预处理阶段就替换掉了）
3. 没有类型安全的检查
   优点：
4. 没有类型的严格限制
5. 针对频繁调用的小函数，不用去建立函数栈帧，提高了效率

为了继续享用宏的优点并规避掉宏的缺点，c++提出了内联函数

所以，啥是内联函数？

概念：
以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调
用建立栈帧的开销，内联函数提升程序运行的效率
内联函数没有调用的消耗， 会在它被调用的地方展开，所以内联也不会建立函数栈帧
既然内联函数这么香，那我们可不可以把所有的函数都搞成内联函数？
注意：是不可以的，因为会造成代码臃肿，内联不建立函数栈帧，直接在你调用的那个地方展开，
如果是比较短小的函数还行，但是如果是一个比较大的函数，比如这个函数有100行代码，你又再程序中调用了100次，那么如果直接在调用的地方展开的话，会直接增加：100*100 = 10000 行代码。
所以：
c++的编译器再看到你使用内联函数时会判断：如果你写的函数很大或是个递归，它就会直接忽略掉内联，转而用普通函数的方式来处理这个。
虽然内联很爽，但是内联函数也有一个坑：声明和定义不能分离
这里指的是：分离和定义不能分离在两个不同的文件中 ，不然会出现链接错误

auto 关键字

1 类型别名思考

随着程序越来越复杂，程序中用到的类型也越来越复杂，经常体现在：

1. 类型难于拼写
2. 含义不明确导致容易出错
   std::map<std::string, std::string>::iterator 是一个类型，但是该类型太长了，特别容
   易写错。聪明的同学可能已经想到：可以通过typedef给类型取别名，比如：

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

使用typedef给类型取别名确实可以简化代码，但是typedef有会遇到新的难题：
在编程时，常常需要把表达式的值赋值给变量，这就要求在声明变量的时候清楚地知道表达式的
类型。然而有时候要做到这点并非那么容易，因此C++11给auto赋予了新的含义。

auto简介

在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，但遗憾的
是一直没有人去使用它，大家可思考下为什么？
C++11中，标准委员会赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一
个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。
【注意】
使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto
的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编
译期会将auto替换为变量实际的类型。

Map::iterator it = m.begin();
while (it != m.end())
{
//....
}
return 0;
}
typedef char* pstring;
int main()
{
const pstring p1; // 编译成功还是失败？
const pstring* p2; // 编译成功还是失败？
return 0;
}
int TestAuto()
{
return 10;
}
int main()
{
int a = 10;
auto b = a;
auto c = 'a';
auto d = TestAuto();
cout << typeid(b).name() << endl;
cout << typeid(c).name() << endl;
cout << typeid(d).name() << endl;
//auto e; 无法通过编译，使用auto定义变量时必须对其进行初始化
return 0;
}

auto的使用细则

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

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

{
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. 在同一行定义多个变量

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

void TestAuto()
{
auto a = 1, b = 2;
auto c = 3, d = 4.0; // 该行代码会编译失败，因为c和d的初始化表达式类型不同
}

auto不能推导的场景

1. auto不能作为函数的参数

// 此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导
void TestAuto(auto a)
{}

2. auto不能直接用来声明数组

void TestAuto()
{
int a[] = {1,2,3};
auto b[] = {4，5，6};
}

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

4. auto在实际中最常见的优势用法就是跟以后会讲到的C++11提供的新式for循环，还有

lambda表达式等进行配合使用

其他：

c++中可以用一个关键字来判断某个变量的类型：
这个关键字就是：typeid

    int d = 1;
	auto e = &d;

	cout << typeid(d).name() << endl;
	cout << typeid(e).name() << endl;

范围for

#define _CRT_SECURE_NO_WARNINGS 1


#include<iostream>
using namespace std;

int main()
{
	//学习 范围for


	//定义一个数组
	int array[] = { 1, 2, 3, 4, 5 };

	//学习范围for之前，我们是这样访问数组的
	for (int i = 0; i < sizeof(array) / sizeof(array[0]); i++)
	{
		array[i] *= 2;
		
	}

	//打印这个数组
	for (int i = 0; i < sizeof(array) / sizeof(array[0]); i++)
	{
		cout << array[i] << " ";
	}

	cout << endl;

	//学习范围for之后，我们可以这样访问数组

	for (auto e : array) //1. 他会依次取数组中的数据赋值给e 2. 自动判断结束 3. 并自动迭代
	{
		//直接打印
		cout << e << " ";
	}

	cout << endl;

	return 0;
}

注意以下情况：

#include<iostream>
using namespace std;
int main()
{
	int array[] = { 1, 2, 3, 4, 5 };

	for (auto x : array)
	{
		x *= 2;             //为啥 我在这里乘以了 2 ，但是打印的结果却还是原来的值；
	}

	for (auto x : array)
	{
		cout << x << " ";
	}

	cout << endl;

	return 0;
}

这个范围for它取值，它是将这个数组里面的值取出来依次赋值给x，就比如他把array[0]取出来，赋值给x之后,再把array[1]取出来赋值给x,依次下去再把array[2]复制给array[3]复制给x。
所以你改变x的值，你并不能影响数组原来当中的值。
那如何才能改变原来数组中的值呢？
很简单：我们把引用加上就好了

#include<iostream>
using namespace std;
int main()
{
	int array[] = { 1, 2, 3, 4, 5 };

	for (auto& x : array)   //在这里把引用加上
	{
		x *= 2;            
	}

	for (auto x : array)
	{
		cout << x << " ";
	}

	cout << endl;

	return 0;
}

给了& 引用之后，x 就相当于是array1,array2…的别名了，所以 修改 x 就可以修改 array 数组了
注意这种情况只能用& 引用，不能用 指针，如果用指针会造成语法错误，没法编译通过。
还有一件事，请判断，下面这种写法能行吗？

#include<iostream>
using namespace std;

void test_for(int array[]) 
{
	for (auto& x : array)
	{
		cout << array[x] << " ";
	}
		
}

int main()
{

	int array[] = { 1, 2, 3, 4, 5 };
	return 0;
}

所以这种写法是不行的。