请回答C++【入门C++】

在学习过C语言初阶和C语言进阶之后，开始正式学习C++，本文主要涉及C++入门引入的内容是C++的关键字、命名空间、缺省参数、IO、函数重载、内联函数、auto关键字、新型for循环、nullptr、引用为面向对象打好基础

1. 关键字

在关键字中，C++对c语言内容进行了添加和补充，C++对比C新增了31个关键字，达到了63个

下面是所有的关键字，在这里暂时混个眼熟即可未来有了一定基础再尝试理解和使用

2. 命名空间

2.1 认识命名空间

C++和Java的诞生普遍目的都是为了解决C语言的一些缺陷

比如namespace 定义的是一个域，为了避免命名冲突和命名污染问题
C语言的库里面，有两个函数用scanf和strlen名称
假设我的代码里面想用这个两个名称命名变量

int main()
{
	int scanf = 10;
	int strlen = 20;
	// C语言解决不了冲突的问题
	scanf("%d", &scanf);
	printf("%d\n", scanf);
	printf("%d\n", strlen);
	return 0;
}

这样就跑不过去
C++可以解决这个问题
通过创建一个命名空间，同时利用::这样一个域作用符来实现名字的隔离,比如下面可以了

namespace allen
{
	int scanf=10;
	int strlen=20;
}
int main()
{
	// Cpp解决冲突
        printf("%x\n", scanf);
	printf("%x\n", strlen);
	scanf("%d", &allen::scanf); 
	printf("%d\n",allen::scanf);
	printf("%d\n",allen::strlen);
	return 0;
}

2.2 命名空间的特点

⚡️普通定义

namespace allen
{
	int scanf=10;
	int strlen=20;
}

⚡️命名空间的嵌套

	namespace allen
{
	int scanf = 10;
	int strlen = 20;
	int Add(int left, int right)
	{
		return left + right;
	}
	namespace n1
	{
		int c;
				int d;
				int Sub(int left, int right)
				{
					return left - right;
				}	
				// 还可以再套
	}
}
int main()	
{
	allen::n1::Sub(10, 4);    
         return 0;
}

⚡️如果同一个工程中有多个名称相同的命名空间，最后编译器将其汇合成一个命名空间中

⚡️同一个域中当然也不能同名

2.3 使用命名空间

首先了解：C++库为了防止命名冲突，把自己库里面的东西都定义在一个std的命名空间中

要使用标准库中的东西，有三种方式

⚡️指定命名空间

	std::cout << "hello world" << std::endl;
	std::vector<int> v;
	std::string s;

问题是麻烦，每个地方要用都要指定，但是他是最规范的方式

⚡️把std整个展开，相当于库里面的东西都到全局域了

namespace allen
{
	int a = 20;
	int b = 10;
}

using namespace allen;//关键字using的使用将命名空间展开到全局

int main()
{
	printf("a的值为：%d\n", a);
	return 0;
}

看起来方便了，如果我们自己定义的东西跟库冲突了就没办法解决了。一夜回到解放前，所以规范的工程项目中是不推荐这种方式的。

⚡️对部分常用的库里面的东西展开

using std::cout;
using std::endl;

int main()
{
	cout << "hello world" << endl;

	return 0;
}

针对1和2折中方案，项目中也会经常用

最后再举一个例子熟悉一下

	int a = 0;

	int main()
{
	int a = 1;
	printf("%d\n", a);
	printf("%d\n", ::a);//空白表示全局域
	return 0;
}

3. I/O输入和输出

3.1 头文件与输入输出函数快速入门

使用cout标准输出（控制台）和cin标准输出（控制台）时，必须包含头文件以及std标准命名空间。cpp中输出输入流的头文件是

下面给出三个输入输出有关的三个函数

⚡️ostream 类型全局对象 cout

⚡️istream 类型全局对象 cin

⚡️ 全局的换行符号 endl

cin的输入格式为cin >> 变量名，cout输出格式cout << 变量名

cin和cout对比printf和scanf的区别就是这两个函数可以自动识别数据的类型，现在不需要在输出的时候写上%+数据类型了，cin也可以不再像scanf那样该一个变量输入值需要取地址且按照相应的格式

使用示例

	int a = 10;
	char str[10];
	std::cin >> a;
	std::cin >> str;
	std::cout << a << str << std::endl;

小结：

cout这种输出形式由于自动匹配，所以大多数情况写起来很方便，但是输出时候含格式就不是很方便，所以可以综合使用，哪个好用就用哪个

4. 缺省参数

4.1缺省参数的定义

⚡️缺省参数是声明或者定义函数时为函数的参数指定一个默认值
⚡️在调用函数的时，如果没有指定实参则采用该默认值，否则使用指定的实参。

// 缺省参数
void TestFunc(int a = 0)
{
	cout << a << endl;
}

int main()
{
	TestFunc(10);
	TestFunc();

	return 0;
}

比如说这里的TestFunc，当传入10的时候就是输出10，否则不传输出0

4.2 缺省参数的分类

4.2.1全缺省参数

我们把所有参数设置为缺省参数

// 全缺省
void TestFunc(int a = 10, int b = 20, int c = 30)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl << endl;
}
int main()
{
	TestFunc(1, 2, 3);
	TestFunc();
	TestFunc(1);
	TestFunc(1,2);
	return 0;
}

4.2.2 半缺省参数

 半缺省
void TestFunc(int a, int b = 20, int c = 30)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl << endl;
}
// 缺省参数的作用是什么，调用更灵活
int main()
{
	TestFunc(1);
	TestFunc(1, 2);
	TestFunc(1, 2, 3);
	return 0;
}

将函数中的部分参数设置为缺省参数

4.3 实际应用

实际开发中，什么时候会用到缺省参数呢？

比如说写数据结构的时候

void StackInit(struct Stack* ps, int InitCapacity = 4)
{
	ps->a = (int*)malloc(sizeof(int) * InitCapacity);
	ps->size = 0;
	ps->capacity = InitCapacity;
}

// 缺省参数-》调用时更灵活
int main()
{
	struct Stack st1;
	// 假设我知道栈里面至少要存100个数据
	StackInit(&st1, 100);
	struct Stack st2;
	// 假设我知道栈里面最多要存10个数据
	StackInit(&st2, 10);
	struct Stack st3;
	// 假设我不知道栈里面可能存多少数据
	StackInit(&st2);

	return 0;
}

这是C语言所做不到的，C++提供的特殊的功能，如果我知道要存多少数据，直接改就可以了，但是如果不知道的话，那就按照默认值

4.4 缺省参数注意事项

缺省值必须是常量或者全局变量

半缺省参数其必须从右到左缺省，并且是连续的

缺省参数不能在函数定义和声明中同时出现

//test.h
void TestFunc(int a = 5);

// test.cpp
void TestFunc(int a = 10)
{
}

C语言不支持

5. 函数重载

5.1 重载快速入门

和Java中的重载是差不多的意思,C++也可以定义同名的函数

函数重载是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数 或 类型 或 顺序)必须不同，常用来处理实现功能类似数据类型不同的问题

int Add(int left, int right)
{
	return left + right;
}

int Add(int left = 10, int right = 20)//缺省参数不是重载，如果写了这个会报错
{
	return left + right;
}

char Add(char left, char right)
{
	return left + right;
}

double Add(double left, double right)
{
	return left + right;
}
int main()
{
	cout << Add() << endl;//如果不把第一个Add注释掉，就会报错
	cout << Add(1, 2) << endl;  // 字面量  给的整形默认算常量
	cout << Add('1', '2') << endl;
	cout << Add(1.1, 2.2) << endl;
	return 0;
}

void f(int a, int b, int c = 1)
{}

void f(int a, int b)
{}

int main()
{
	f(1, 2, 3);
	// f(1, 2);//err产生了二义性
	return 0;
}

所以重载和缺省不能乱用，注意不能踩坑

void swap(int* a, int* b)
{
	// ...
}
void swap(double* a, double* b)
{
	// ...
}
int main()
{
	int x = 0, y = 1;
	swap(&x, &y);
	double m = 1.1, n = 2.2;
	swap(&m, &n);
	return 0;
}

看上去，调用起来更加舒服

⚠️ 注意：返回值不同不构成重载,比如下面的

short Add(short left, short right)
{
return left+right;
}
int Add(short left, short right)
{
return left+right;
}

5.1 名字修饰

此时我们对函数重载提出了疑问

5.1.1为什么C语言不支持重载，C++是怎么实现的

要解决这些个问题需要Linux来辅助演示

⚡️ Linux修饰规则

首先我们知道在C/C++中，一个程序要运行起来，需要经历以下几个阶段：预处理、编译、汇编、链接。

实际我们的项目通常是由多个头文件和多个源文件构成，而通过编译链接，我们可以知道，【当前a.cpp中调用了b.cpp中定义的Add函数时】，编译后链接前，a.o的目标文件中没有Add的函数地址，因为Add是在b.cpp中定义的，所以Add的地址在b.o中。那么怎么办呢？
所以链接阶段就是专门处理这种问题，链接器看到a.o调用Add，但是没有Add的地址，就会到b.o的符号表中找Add的地址，然后链接到一起。
那么链接时，面对Add函数，连接器会使用哪个名字去找呢？这里每个编译器都有自己的函数名修饰规
则。
由于Windows下vs的修饰规则过于复杂，而Linux下gcc的修饰规则简单易懂
通过下面我们可以看出gcc的函数修饰后名字不变。而g++的函数修饰后变成【_Z+函数长度+函数名+类型首字母】。

在linux下，采用gcc编译完成后，函数名字的修饰没有发生改变。

在linux下，采用g++编译完成后，函数名字的修饰发生改变，编译器将函数参数类型信息添加到修改后的名字中。

简单点说的话就是在函数链接的时候，重载的函数的地址和命名是不同的，所以区分了同名函数

⚡️Windows修饰规则

对比Linux的修饰规则，Windows的则会复杂很多，变换更多

还可以参考如下网站学习函数调用约定和名字修饰规则

C++函数重载
C/C++的调用约定

通过这里就理解了C语言没办法支持重载，因为同名函数没办法区分。而C++是通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不一样，就支持了重载。

另外我们也理解了，为什么函数重载要求参数不同，而跟返回值没关系。

5.1.2 extern "C"的作用是什么

有时候在C++工程中可能需要将某些函数按照C的风格来编译，在函数前加extern “C”，意思是告诉编译器，将该函数按照C语言规则来编译。

tcmalloc是google用C++实现的一个项目，他提供tcmalloc()和tcfree两个接口来使用。这些中间件程序，通常我们把它编译成静态库或者是动态库，C++可以找到并使用，这些但如果是C项目就没办法使用，因为修饰方式不同所以找不到，那么解决方法就是使用extern “C”来解决。这样的话C程序也可以调用的了这个库

解决的就是取名时候有extern “C”，也就表示最后链接的时候不要再加名字修饰规则了

而C++也可以通过extern “C”，可以导致都C/C++都可以调用了

不过，这个函数不能重载了

确实用了很多extern "C "

6. 引用

C++中，新引入的引用和指针互相是对标的

6.1 引入的概念

⚡️我们把a改变了值，b也会相应的改变

⚡️同时两个值的地址也是一样的

如何使用引用呢？

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

int main()
{
	int a = 10;
	// b是a的引用(别名)
	int& b = a;
	b = 20;
	int& c = b;
	c = 30;
	return 0;
}

别名是可以套娃取的

6.2 引用的功能

void swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
void swap(int& r1, int& r2)
{
	int tmp = r1;
	r1 = r2;
	r2 = tmp;
}
int main()
{
	int a = 1, b = 2;
	swap(&a, &b);
	swap(a, b);
	return 0;
}

引用简化了指针的效果，可以说很好用

struct Stack
{
	int* a;
	int size;
	int capacity;
};
void StackInit(struct Stack* ps)
{}
void StackInit(struct Stack& s)
{}
int main()
{
	struct Stack st;
	StackInit(&st);
	StackInit(st);
	return 0;
}

有时候引用简化了使用二级指针

6.3 引用特点

引用在定义时必须初始化
一个变量可以有多个引用
引用一旦引用一个实体，再不能引用其他实体
引用类型必须和引用实体是同种类型的

double d = 12.34;
int& rd = d; // 该语句编译时会出错，类型不同

常引用不能放大权限，常变量的引用也得是常引用

const int a = 10;
//int& ra = a; // 该语句编译时会出错，a为常量
const int& ra = a;//应该如此

常引用权限可以缩小，但是不可以放大

int& b = 10; // 
const int& b = 10;//缩小权限是可以接受的
const int& rd = d;
}

在c中有一个隐式类型转换，现在有一个奇特的语法,const之后可以“隐式转换”引用类型

	int c = 10;
	double d = 1.11;
	d = c; // 隐式类型转换
	
	int c = 10;
	double& rc = c;//err
	const double& rc = c;//pass

原因是这样的，语法层的理解是：在隐式类型转换的时候，int c会产生一个double类型的临时变量，且这个临时变量具有常性，所以加一个const就可以了

6.4 引用场景快速入门

6.4.1 做参数

比如Swap函数

void Swap(int& left, int& right)
{
int temp = left;
left = right;
right = temp;
}

6.4.2 返回值

传值返回，返回的对象的临时拷贝

传引用返回，返回的是对象的引用

传值返回

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

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

如果返回值用传值法返回int的话，由于是临时变量，是一个具体的空间，且具有常性，所以要加const

传引用返回

不建议的返回形式

int& Add(int a, int b)
{
	int c = a + b;
	return c;
}
int main()
{
	int ret = Add(1, 2);    
}    

感觉好像没有问题其实有问题,因为Add函数相当出了函数栈帧,栈帧就销毁,那么这块空间相当于已经不属于这个赋引用值的ret了,也就是说,如果此时再要访问,虽然空间暂时没有被销毁,但是已经是越界访问了,结果是不确定的，就好像酒驾，不报错不代表没有问题

有时会输出随机值,比如

int& Add(int a, int b)
{
	int c = a + b;
	return c;
}
int main()
{
	int& ret = Add(1, 2);
	Add(5, 7);
	cout << ret << endl;
	printf("hello world\n");
	cout << ret << endl;
	return 0;
}

因此一般的代码是不能够用引用返回的

那么什么时候可以利用呢?把属性变成静态的就可以了,这样的话不会被销毁

int& Add(int a, int b)
{
	static int c = a + b;
	return c;
}
int main()
{
	int& ret = Add(1, 2);
	Add(5, 7);
	printf("hello world\n");
	cout << ret << endl;
	return 0;
}

小结:

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

所以说想要用就把该对象置为static属性就可以了

6.5 传值、传引用效率比较

不是说传引用返回一无是处,还是有优点的

先看看传引用作为参数的情况

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

再看看返回值的情况

#include 
struct A { int a[10000]; };
A a;
// 值返回
A TestFunc1() { return a; }
// 引用返回
A& TestFunc2() { return a; }
void TestReturnByRefOrValue()
{
	// 以值作为函数的返回值类型
	size_t begin1 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc1();
	size_t end1 = clock();
	// 以引用作为函数的返回值类型
	size_t begin2 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc2();
	size_t end2 = clock();
	// 计算两个函数运算完成之后的时间
	cout << "TestFunc1 time:" << end1 - begin1 << endl;
	cout << "TestFunc2 time:" << end2 - begin2 << endl;
}
int main()
{
	TestReturnByRefOrValue();
 }

所以说,当参数和返回值都是比较大的变量时,传引用传参和传引用作为返回值还可以提高效率,只要符合条件,尽量用引用传参,传返回值,避免一些深拷贝

6.6 指针VS引用

在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。

	// 在语法上，这里给a这块空间取了一个别名，没有新开空间
	int& ra = a;
	ra = 20;
	// 在语法上，这里定义个pa指针变量，开了4个字节，存储a的地址
	int* pa = &a;
	*pa = 20;

在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。

引用和指针的汇编代码对比,其实底层很像，区别只在换了个别名

6.6.1 引用和指针的不同点:

引用概念上定义一个变量的别名，种子很存储一个变量的地址
引用在定义时必须初始化，指针没有要求
引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
不能直接NULL引用，但有NULL指针

int* p = NULL;
int*& rp = p;
	cout << rp << endl;

在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)
引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
有多级指针，但是没有多级引用
访问实体方式不同，指针需要显式解引用，引用编译器自己处理
引用比指针使用起来相对更安全

下面我们混合一下指针和引用，来看看下面一段代码的意思

	int* pa = &a;
	*pa = 20;

	int b = 10;
	int*& rpa = pa;
	rpa = &b;

先是pa指针放着a的地址，再让rpa对pa取别名，然后让rpa引用b的地址，同时pa的地址也改变了

7. 内联函数

7.0 Intro of inline

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

还记得C语言为了小函数避免建立栈帧，提供了宏函数支持，预处理阶段展开，既然C语言已经解决了，为什么C++还要提供inline函数呢？（宏函数的缺点）

C++推荐频繁调用的小函数，定义成inline，会在调用的地方展开，没有栈帧开销

7.1 宏函数的优缺点即内联函数的优点

优点

增强代码的复用性。
提高性能。

缺点

预处理阶段展开,无法调试

宏的语法复杂，容易出错

没有类型安全的检查

###写一个Add的宏函数

注意还是比较容易写错的

// #define ADD(int x, int y) return x + y 典型的错误写法
// #define ADD(x, y) x+y;// 不能带分号 err
// #define ADD(x, y) (x)+(y) //err
#define ADD(x, y) ((x)+(y))

那么C语言宏函数的缺点就是C++内联函数的优点

C++有哪些技术替代宏？

1. 常量定义 换用const
2. 函数定义 换用内联函数

7.2 内联函数快速入门

凡是在汇编中看到有call的一般就是要开辟函数栈帧，不内联的函数就是含call的

怎么样才能看到内联函数具体的汇编呢，想要把debug改成release版，因为debug版本为了方便调试，没有展开内联函数，可以看到内联函数确实没有call，即开一个函数栈帧

但是下面的情况还是会产生影响，来看一下

指令多代表效率低吗，不是这样的，指令多，但是不用开栈帧，所以还是快，问题在于内联是在用空间换时间，当然编译器也是有底线的，函数太大不会让你内联的

7.3 内联函数特点

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

8. auto关键字

8.0 Intro of auto

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

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

8.1 auto快速入门

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

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

int main()
{
	int x = 10;
	auto a = &x;  // int* 
	auto* b = &x; // int*
	int& y = x;   // y的类型是什么？int
	auto c = y;  // int 
	auto& d = x; // d的类型是int， 但是这里指定了d是x的引用
	// 打印变量的类型
	cout << typeid(x).name() << endl;
	cout << typeid(y).name() << endl;
	cout << typeid(a).name() << endl;
	cout << typeid(b).name() << endl;
	cout << typeid(c).name() << endl;
	cout << typeid(d).name() << endl;
	return 0;
}

上面的auto可以自动推导出声明的类型是什么，auto干的就是这个工作

typeid(x).name()用来打印变量的类型

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

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

8.2 auto不能推导的类型

auto不能作为函数的参数

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

auto不能直接用来声明数组

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

为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法
auto在实际中最常见的优势用法就是跟C++11提供的新式for循环，还有lambda表达式等进行配合使用。

9 新型for循环

9.1 范围for的语法

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

新for循环，和Java的foreach增强for循环很像

int main()
{
	for (auto& e : array)
	{
		e *= 2;
	}
	for (auto ee : array)
	{
		cout << ee << " ";
	}
	cout << endl;
	return 0;
}

9.2 范围for的使用条件

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

void TestFor(int array[])//没给范围不可以，err
{//传进来的已经变成指针了
	for(auto& e : array)
	cout<< e <<endl;
}

迭代的对象要实现++和==的操作。

int main()
{
	int array[] = { 1, 2, 3, 4, 5 };
	// 范围for C++11新语法遍历，更简单，数组都可以
	// 自动遍历，依次取出array中的元素，赋值给e，直到结束
	for (auto e : array)
	{
		e *= 2;
	}
	for (auto ee : array)
	{
		cout << ee << " ";
	}
	cout << endl;
	return 0;
}

打印出来是12345 而不是 246810，说明e *= 2;，没起作用，这是因为该for循环本质是通过船舰一个临时拷贝，所以出了循环改变就消失了

有如下解决方法，把做运算的for循环写成引用类型即可

	for (auto& e : array)
	{
		e *= 2;
	}

如图片使用涉及侵权请私信联系我删除，谢谢

10. 指针空值nullptr(C++11)

10.1 nullptr快速入门

在良好的C/C++编程习惯中，声明一个变量时最好给该变量一个合适的初始值，否则可能会出现不可预料的
错误，比如未初始化的指针。如果一个指针没有合法的指向，我们基本都是按照如下方式对其进行初始化：

NULL实际是一个宏，在传统的C头文件(stddef.h)中，可以看到如下代码：

#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif

可以看到，NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量。不论采取何种定义，在
使用空值的指针时，都不可避免的会遇到一些麻烦

NULL会被认为是一个int，而只有nullptr才是会被看做一个指针

void f(int i)
{
	cout << "f(int)" << endl;
}
void f(int* p)
{
	cout << "f(int*)" << endl; 
}
int main()
{
	int* p1 = NULL; //  int* p1 = 0; 
	int* p2 = nullptr;
	f(0);
	f(NULL);
	f(nullptr);
	return 0;
}

程序本意是想通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义成0，因此与程序的初衷相悖。
在C++98中，字面常量0既可以是一个整形数字，也可以是无类型的指针(void*)常量，但是编译器默认情况下将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转(void *)0。

10.2 nullptr注意事项

在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的。

在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。

为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。

兄弟们 干净又卫生