①.【命名空间】

在C/C++中，变量，函数和类都是大量存在的，而这些变量，函数，和类的名称都将存在全局作用域中，这样可能就回引起很多冲突：比如命名冲突。

• 命名冲突

1.我们跟库冲突

2.我们互相之间冲突

而我们使用命名空间的目的就是为了解决C语言大多缺陷<命名冲突>。

使用命名空间可以对标识符的名称进行本地化，从而避免命名冲突或名字污染。

1.编译器访问域顺序 --局部域>全局域–>展开命名空间域or指令访问命名空间域。

2.命名空间展开就是展开到全局里来，是编译器是否会到命名空间域中访问搜索。

#include <stdio.h>
#include <stdlib.h>
int rand = 10;
int main()
{
 printf("%d\n", rand);
return 0;
}
//比如我们在这里定义一个全局变量rand，想要打印rand。
//但是编译器会报错，因为显示重定义。
为什么呢？因为引用了头文件后，头文件里就有rand函数的定义，在头文件里rand定义为函数，而在这里又被定义为全局变量，所以产生了命名冲突。

由于在C语言中该类问题无法解决，所以在C++中提出了使用namespace来解决

1.命名空间定义

库里的名称我们无法改变，那我们可以将自己定义的名称放在命名空间里，当需要时指令访问即可。

那怎么定义命名空间呢？

定义命名空间，需要使用关键字namespace，后面跟着命名空间名子，然后再接着一个{}即可。

{}里即为命名空间的成员，可以是变量，函数，类。

namespace定义的命名空间就相当于定义一个域–可以与其他域隔离。也就是将自己定义的变量，函数，类，划到一个新的域中，让全局域找不到自己。

常见域：

1.类域

2.命名空间域

3.局部域

4.全局域

Ⅰ.正常定义命名空间

namespace wei
{
  int a = 10;//可以定义变量
  int Add(int x, int y)//可以定义函数
  {
    return x + y;
  }
  struct Node//可以定义类
  {
    int data;
    struct Node* next;
  };
}

Ⅱ.嵌套定义命名空间

命名空间是可以嵌套的

比如C++库名字就叫std里面就嵌套着许多命名空间。

namespace tao1
{
  int a = 10;
  int b = 20;
  namespace tao2
  {
    int a = 1;
    int b = 2;
    namespace tao3
    {
      int a = 3;
      int b = 4;
    }
  }
}

Ⅲ.合并命名空间

在不同的头文件里，最后同名的命名空间会合并成一个。

也就是在同一个工程中允许多个相同名称的命名空间，编译器最后会合成同一个命名空间中的

//test.cpp文件
namespace tao1
{
  int a = 10;
  int b = 20;
  namespace tao2
  {
    int a = 1;
    int b = 2;
    namespace tao3
    {
      int a = 3;
      int b = 4;
    }
  }
}
//test.h文件
namespace tao1
{
  int max;
  int min;
  int a = 10;
  int b=30;
}

2.命名空间的使用

定义好命名空间后，我们可以在命名空间里定义我们想要定义的变量，函数，类，并且不需要担心和库里函数发生命名冲突。

不过当我们要使用这些命名空间里的成员时，该如何使用呢？

::域作用限定符

Ⅰ.+命名空间名称及域作用限定符

namespace wei
{
  int a = 10;//可以定义变量
  int Add(int x, int y)//可以定义函数
  {
    return x + y;
  }
  struct Node//可以定义类
  {
    int data;
    struct Node* next;
  };
}
int main()
{
  printf("%d", wei::a);//加命名空间名称与域作用限定符
  return 0;
}

Ⅱ.using成员引入

namespace wei
{
  int a = 10;//可以定义变量
  int Add(int x, int y)//可以定义函数
  {
    return x + y;
  }
  struct Node//可以定义类
  {
    int data;
    struct Node* next;
  };
}
using wei::Add;//使用using将命名空间中某个成员引入。
int main()
{
  printf("%d\n", wei::a);
  printf("%d\n", Add(2, 5));
  return 0;
}

Ⅲ.using namespace名称全部引入

namespace wei
{
  int a = 10;//可以定义变量
  int Add(int x, int y)//可以定义函数
  {
    return x + y;
  }
  struct Node//可以定义类
  {
    int data;
    struct Node* next;
  };
}
using namespace wei;//使用using namespace命名空间名称将命名空间内容全部展开。
int main()
{
  printf("%d\n", wei::a);
  printf("%d\n", Add(2, 5));
  struct Node n;
  return 0;
}

但这种做法是有风险的。

3.注意事项

当我们使用第三种方法来访问命名空间里的成员时，会存在风险，因为命名空间全部展开到全局域中，就又会出现命名冲突的风险。比如如果全部展开C++标准库就会存在风险。

• using namespace std；

1.直接展开会有风险：当我们定义如果和库重名那就会报错

2.建议项目里面不要直接展开，建议日常练习可以直接展开

3.项目中建议指定展开，不要轻易展开命名空间。

不过我们还可以这样：

如果有重复多使用的可以【部分展开】：【指定展开】：【把常用的展开】

using std::cout;//将常用的成员展开使用
using std::end1;//将常用的成员展开使用

Ⅰ.概念

当声明或定义函数时，为函数的参数指定一个缺省值，也叫做默认值。

规则：

当调用该函数时，如何没有没有指定实参则采用改形参的默认值。

当调用该函数时，指定实参，那就使用传过来的实参。

通俗的说就是：

没有传参时，使用参数的默认值

传参时，使用指定的实参

void fun(int n=10)
{
  cout << n << endl;
}
int main()
{
  fun();//没有指定实参，则使用缺省参数
  fun(20);//指定实参
}

1.全缺省参数

全缺省参数，即函数形参都被指定为缺省值

using namespace std;
void fun(int a=1,int b=2,int c=3)
{
  cout << a<< endl;
  cout << b << endl;
  cout << c << endl;
}
int main()
{
  fun();//全缺省参数，形参全部指定为缺省值，不传实参
}

2.半缺省参数

半缺省参数，即函数形参部分被指定为缺省值

void fun(int a,int b=2,int c=3)
{
  cout << a<< endl;
  cout << b << endl;
  cout << c << endl;
}
void fun2(int a,int b, int c = 9)
{
  cout << a << endl;
  cout << b << endl;
  cout << c << endl;
}
int main()
{
  fun(2);//部分缺省，部分形参指定为缺省值
  fun2(5, 6);
}

3.使用规则

• 1.传参是从左向右传，不能隔着传。
• 2.而缺省参数是从右到左缺省。
• 3.声明和定义不能同时给缺省

为什么声明和定义不能同时给缺省呢？？？

因为会出现这样的场景：当声明和定义的缺省参数不一致时，那编译器到底该用哪个缺省值呢？

• 4.准确的来说，只能在声明函数的时候来给缺省，定义时候不能给。
• 5.缺省值必须是常量或者全局变量
• 6.默认参数也叫缺省参数

4.应用场景再现

比如顺序表中有静态顺序表和动态顺序表。我们知道静态顺序表，写死了固定大小，很不好使，但动态顺序表又需要不断的扩容，扩容操作是需要消耗效率的。所以我们可以利用缺省参数，来对顺序表的默认大小进行缺省，当我们知道要插入多少数据时，则指定传相对的大小，那顺序表一开始就会开辟那么大的空间，就不需要从一小块不断扩容了。而当我们不知道要插入的数据时，那么就按照给定的默认值(缺省值)来进行开辟空间。

typedef struct SQList
{
  int* a;
  int size;
  int capacity;
}SQList;
void SQInit(SQList *s,int defalutCapacity=4)
{
  s->a = (int*)malloc(sizeof(SQList) * defalutCapacity);
  if (s->a == NULL)
  {
    perror("malloc");
  }
}
int main()
{
  SQList s;
  SQInit(&s);//如果不知道要插入多少数据，那就按照默认值4来
  SQInit(&s, 100);//如果知道要插入多少数据，那么直接就开辟这么大的空间，不需要不断的扩容到100
}

②.函数重载

C语言不允许存在同名函数，但C++允许存在同名函数，这么做的原因是用来处理实现功能类似数据类型不同的问题。

那C++是如何做到让同名函数同时存在的呢？

Ⅰ.概念

函数重载：是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参( |参数个数|或类型|或类型顺序|)不同。

1.参数个数不同

//参数个数不同
int Add2(int left, int mid,int right)//3个参数
{
  return left+mid + right;
}
int Add(int left, int right)//2个参数
{
  return left + right;
}
int main()
{
  printf("%d\n", Add(1, 1));//编译器会自动识别使用哪一个函数的
  printf("%d\n", Add2(1,2,3));
}

参数个数不同：

void f()
{
  cout << "f()" << endl;
}
void f(int a)
{
  cout << "f(int a)" << endl;
}

不过要注意的是下面这个例子

void f()
{
  cout << "f()" << endl;
}
void f(int a=0)
{
  cout << "f(int a)" << endl;
}

你觉得它构成函数重载吗？

从定义的角度来说，它确实是一个没有参数，一个有一个参数，它们参数个数不同，函数名相同，所以是构成函数重载的。但有没有什么问题呢？

你看，第二个函数的参数被缺省了，也就是相当于当函数传参时，传不传都无所谓，传参数，那就使用这个实参，如果不传，那就使用缺省参数。那么问题来了，如果我们不传参数，到底调用的是第一个函数，还是调用第二个函数呢？

第一个函数没有参数，如果我们不传参正常来说就应该调用第一个，但第二个同名函数的参数被缺省了。所以就会出现

调用不明确问题。

2.参数类型不同

//参数类型不同
int Add(int left, int right)//int 类型
{
  return left + right;
}
double Add(double left, double right)//double 类型--注意这里返回值是double ，不需要管返回值类型
{
  return left + right;
}
int main()
{
  printf("%d\n", Add(1, 1));
  printf("%f\n", Add(1.1, 1.1));//编译器会自动识别数据类型，并且使用相应的函数
}

3.参数类型顺序不同

void fun1(int a, char c)
{
  cout << a << " " << c << endl;
}
void fun1(char c, int a)
{
  cout << c << " " << a << endl;
}
int main()
{
  fun1(1,'x');
  fun1('w', 6);
}

要明确注意的是这里是类型顺序，而不是变量顺序。

比如下面这个坑

void fun1(int a, char c)
{
  cout << a << " " << c << endl;
}
void fun1(int c, int a)
{
  cout << c << " " << a << endl;
}

你觉得构成重载吗？

当然不构成了，我们要严格按照定义，是类型顺序不同如果是上面这个例子，那我要传fun1(1,'x');到底调用的是哪一个函数呢，是上面的还是下面的呢？所以是有歧义的。

c++虽然允许同名函数并且会自动识别变量类型

但要严格遵守函数重载的规则才可以。

4.对返回值没有要求

函数重载对函数的返回值是没有要求的。

返回值没有要求，但是当后面的要求不符合是，仍然不能构成重载(函数参数类型不同，函数参数的个数不同，函数类型顺序不同)

返回值没有要求 --不构成重载 —无法使用

int Add(int left, int right)
{
 cout << "int Add(int left, int right)" << endl;
 return left + right;
}
double Add(double left, double right)
{
 cout << "double Add(double left, double right)" << endl;
 return left + right;
}

比如这样，两个同名函数符合参数类型不同，所以构成重载。虽然它们返回值不同，但函数重载对返回值没有要求。

③.函数名修饰规则

为什么C语言不支持函数重载，而C++支持重载呢？

C++又是如何支持的呢？

这其中就要涉及程序的【编译与链接过程】与【函数名修饰规则】

假设一个工程里有三个文件，一个是专门声明各函数的文件，一个是专门定义各函数的文件，一个是用来测试这些函数功能的文件。

我们知道一个程序要通过预编译，编译，汇编，链接四个部分才可以生成可执行程序。

而各个阶段的处理也不相同。

大体是就是在预编译阶段，在声明和定义的两个文件里包含的头文件会被展开，宏会被替换，还有注释会被去掉。

然后各生成一个带 .i的文件。在编译阶段会进行检查语法，生成汇编代码，并生成一个带.s的文件。

汇编阶段会进行将汇编代码转化为机器指令，生成一个符号表，并生成一个带.o的文件，最后在链接阶段，会将符号表合并和重定位，将两个带.o文件链接成一个可执行程序。

根据函数栈帧的创建和销毁，我们知道当调用一个函数时，会执行一个call的汇编代码。call后面就是函数的地址。然后就会使用jump跳进调用的函数里。

而在实际的项目中通常是由多个头文件和多个源文件。

比如在test.c文件里调用了定义.c文件里的函数A，在链接之前，test.o文件里是没有函数A的地址的，因为函数A的地址在定义.c文件里。

那么test.c程序如何执行呢？

在链接阶段会解决这个问题，链接器看到test.o调用函数A，但是又没有函数A的地址，它就会到定义.o符号表中去找函数A的地址，然后重定位到一起。

我们可以这样比喻：将在.h头文件里声明的看成一种承诺

test.c想要买房，还差钱，向好兄弟.h文件借钱，好兄弟.h满口答应。给定了test.c承诺。

test.c有了承诺，它就敢买房了，这个过程是合法的。所以不会报错的。

但要真正的买到房，还需要.h兑现承诺，而如果.h找到定义的文件就可以兑现承诺了。

所以test.c要执行起来就需要找到定义来兑现承诺。

链接的作用就是：找到定义(兑现承诺)。

那还有一个问题，链接器是如何找定义的呢？是找哪个定义的呢？

是使用哪个名字定义的呢？

在不同的编译器有不同的函数名修饰规则。

Ⅰ.C/C++的不同

我们举例gcc和g++的例子。

• 1.C语言编译器编译结果：

我们发现gcc的函数修饰后名字是不改变的。

• 2.C++编译器编译器结果：

而在g++的函数修饰后变成了【_Z+函数长度+函数名+类型首字母】

• 3.结论：采用C语言编译器编译后，函数名没有改变，而采用C++编译器编译后，函数名经过函数修饰发生改变，并且跟函数的参数类型，参数个数等有关。

• 4.通过这里我们就可以理解C语言没有办法支持重载了，因为C编译器，在编译后，同名函数没有办法区分，而C++经过函数修饰规则，根据函数参数的类型，参数的个数不同而改变函数的名字进行区分，只要参数不同，修饰后的函数名就不一样，这样就支持重载了。

• 5.如果两个函数函数名和参数都是一样的，但是函数返回值不一样，这是不构成重载的，因为重载的定义没不包括返回值。编译器没有办法区分。

【C++入门必备知识：|引用| +|auto关键字| + |范围for|】

在这里插入图片描述

④.引用

Ⅰ.引用概念

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

比如水浒传里的李逵

小名叫铁牛，江湖人称黑旋风。这些都是他，只不过名字不同。

Ⅱ.引用使用

类型& 引用变量名=引用实体

int main()
{
  int a = 10;
  int& ra = a;//给变量a取别名为ra
  int& rra = ra;//又给变量rra取别名为rra ，其实本质上都是a
  printf("%p\n", a);
  printf("%p\n", ra);
  printf("%p\n", rra);
}

从语法上我们看，就是给a取别名，并没有开辟空间。

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

Ⅲ.引用特性

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

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

3.引用一旦引用一个实体，再不能引用其他实体。 C++的引用不能改指向

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

就像李逵可以有多个别名一样。

int main()
{
  int a = 10;
  int& ra = a;
  int& rra = a;
  printf("%p\n", a);
  printf("%p\n", ra);
  printf("%p\n", rra);//它们的本质都是a
}

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

你要取别名，倒是说给谁取别名呀，你不说谁知道这个名字是谁的。

int main()
{
  int a=10;
  int&ra;//这样是不可以的，编译器会报错。
  //引用在定义时必须要初始化。
}

3.引用一旦引用一个实体，再不能引用其他实体。

int main()
{
  int a = 10;
  int&ra=a;
  int b=20;
  ra=b;//这里ra=b是将b的值赋给ra，而不是让ra变成b的别名。C++的引用不能改指向。ra仍然是a的别名
}

注意：

同一个域不能同名引用，不能域里可以同名，但在不同域里是可以同名的，是可以区分的。

Ⅳ.使用场景

引用第一使用场景：

1.做函数参数

void Swap(int*a, int* b)
{
  int tmp = a;
  a = b;
  b = tmp;
}
//引用
void Swap(int& a, int& b)
{
  int tmp = a;
  a = b;
  b = tmp;
}

意义：

1.引用做参数–【输出型参数】

什么叫输出型参数呢？就是传进去使用还要带出来

这里利用形参就是实参的变名，改变形参就改变了实参

不同于传指针参数。

2.引用做参数—【提高效率】

对于/大对象/深度拷贝的数据是可以提高效率的。

因为是引用不开空间

#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();
}

虽然指针也能做到上面的功能。

但是引用更方便。

引用第二大使用场景：

2.做函数返回值

int fun()//返回值就用int来接受
{
  int n = 0;
  n++;
  return n;
}
int main()
{
  int ret = fun();//最后将返回值返回ret
  printf("%d ", ret);
}

没有毛病吧。根据函数栈帧的创建和销毁我们知道，在函数调用完时，函数栈帧会销毁，而这个返回值将会保存在一个寄存器中，相当于一个临时变量。操作系统会开辟一个临时变量来保存这个返回值，如何再将临时变量赋给ret。最后ret得到了函数的返回值。

而这个过程需要需要创建临时变量，那么就需要开销。

其实只要看函数返回值，只要是传值返回的

不管怎么样编译器都会生成临时变量。

但是当用引用作为返回值时，最后就不需要创建临时变量了。

也就是传引用返回就不会生成临时变量。

int& fun()//用引用作为返回值
{
  static int n = 0;
  n++;
  return n;//最后函数返回的是n的别名，不需要创建临时变量保存，因为别名不需要开辟空间
}
int main()
{
  int ret = fun();//fun的返回值就是n的别名，别名不需要开辟空间，中间没有临时变量，直接就赋值会ret了。
  printf("%d ", ret);
}

那我们是不是以后函数返回值都用引用呢？

当然不行了，上面的案例也是特殊的，因为static修饰的变量在静态区，当函数栈帧销毁时，并不影响变量a，所有当引用取别名时可以找到它。

所以这里打印的ret的值是不确定的。

如果fun函数结束，栈帧销毁，没有清理栈帧，那么ret的结果是侥幸是正确的。

如果fun函数结束，栈帧销毁，清理栈帧，那么ret的结果是随机值。

意义：

1.减少拷贝，提高效率

但要记住并不是任何地方都可以引用返回值

当函数 返回值为局部变量时，这种是不行的。

因为返回局部对象引用很危险。最后的结果取决于函数调用完栈帧销毁不销毁

当返回值为静态变量时不危险，函数调用结束，函数栈帧销毁不影响静态变量的存在。

不会有随机值的问题。静态变量还在，那么取别名就合法。

传引用返回–没有创建临时变量，只是取别名。别名==变量。

返回变量的别名，没有临时变量，也没有拷贝。所以可以提高效率。

传值返回–需要开辟临时变量-再拷贝回去。

引用返回门槛：不能随意引用传参返回

1.基本任何场景都可以用引用传参

2.但要谨慎用引用返回，出了函数作用域，对象不在， 就不能用引用返回，还在就能用。

2.查改返回值

引用做返回值，可以修改返回值，和获取返回值。

因为返回值就是这个要修改或者要返回变量的别名，对别名修改或者获取。就是修改该变量。

Ⅵ.常引用

1.引用过程中，权限不能放大

int main()
{
  1.//引用过程中，权限不能放大
  const int a = 0;//表示a不能修改
  int& b = a;//不能通过引用别名来修改a，这种方法是错误的。
    2.//引用过程中，权限是可以平移或缩小的。
    int x=0;
    int &y=x;
    const int&z=x;
    3.//对z这个别名进行修饰，也就是z这个别名权限缩小了。但其他别名的权限还是正常的。 
    ++x;
}

2.不能引用带有常性的变量。

double a=1.2;
int b=a;
//其实在类型转化会产生临时变量，产生一个int 类型的临时变量
int&bb=a;
//这个也是一样，a是double类型，别名bb是int类型，发生类型转化，然后产生一个临时变量存在着dd，这个dd就具有常性了，因为临时变量具有常性。

而带有常性的变量就不能使用引用了。

Ⅶ.引用与指针区别

1.引用在语法概念上就是一个别名，没有开辟空间，和其引用的实体共用同一块空间。

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

不同点：

-1.引用概念上是定义一个变量的别名，指针是存储一个变量的的地址

-2.引用在定义时，需要初始化，指针没有要求。

-3.引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在如何时候指向任何一个同类型实体。

-4.没有NULL引用概念，但有NULL指针

-5.有多级指针，但是没有多级引用。

-6.引用比指针使用起来更安全。

-8.在sizeof下含义不相同：在引用用计算的就是别名类型的大小，而指针是固定的，始终是地址空间所占字节个数。(32位下4字节)

-9.引用自加表示引用的实体加1，而指针自加，表示指针向后偏移一个类型的大小。

⑤.auto关键字

在C++11中，auto的作用是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。

    int a = 0;
  auto b = a;//auto可以自动识别a的类型
  auto c = 's';//自动识别字符‘s’的类型

还有要注意在使用auto时定义变量时，必须要对其进行初始化

  int a=0;
  auto b;//使用auto却不初始的编译器会报错
  auto c ;//这样不初始化是不对的。

【注意】

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

1.使用规则

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

用auto声明指针类型时，用auto和auto没有区别。*

但用auto声明引用类型时，必须加上&。

  int a=0;
  auto pa=&a;//auto与指针和引用结合使用
  auto* pa = &a;
  auto&ra=a;

2.在同一行定义多个变量。

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

  auto a = 1, b = 2;
  auto c = 3, d = 4.0;//这样就不对了，auto一行定义多个变量虽然可以，但是要求这一行变量类型都相同才可以。d的类型与c不同

3.auto不能作为函数的参数。

void fun(auto a)//这种写法是不允许的
{}

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

 int a[]={6,5,4};
 auto c={9,8,7};//这种写法是不允许的。

⑥.基于范围的for循环

如果我们想要打印一个数组，就必须遍历这个数组，而遍历这个数组就得需要知道这个数组的大小是多少。

int main()
{
  int a[] = { 9,8,7,6,5,4,3,2,1 };
  int n = sizeof(a) / sizeof(a[0]);
  for (int i = 0; i < n; i++)
  {
    cout << a[i] << endl;
  }
  return 0;
}

而对于我们来说，这种写法有时会出现很多问题，比如数组大小计算错误，或者循环条件写错，所以C++11中引入了基于范围的for循环。

for循环后面的括号由冒号" ："分为两个部分，第一部分是范围内用于迭代的变量类型，第二部分则表示被迭代的范围。

for(auto__:__);

int arr[] = { 9,8,7,5,6,3,2,4 };
  for (auto e : arr)
  {
  cout << e << endl;  
  }

1.使用规则

1.使用于数组

2.依次取数组中的数据赋值给e（这里的e可以随便写其他，没有规定，可以是x，可以是y）

3.自动迭代，自动判断结束。

4.与普通循环类似，可以用continue来结束本次循环，也可以用break跳出整个循环。

还有如果想要利用范围for改变数组内容该任何改变呢？

如果想让数组内数据都变成2倍这样写可以吗？

int arr[] = { 9,8,7,5,6,3,2,4 };
  for (auto x : arr)
  {
    x * 2;
  }

要注意，这里只是将arr数组内容依次赋值给x，但x改变能改变数组内的数据吗？当然不能了。

所以我们想要改动数组内的数据，只要传引用即可，每次改变的是数组数据的别名。改变别名就改变了数组数据。

int arr[] = { 9,8,7,5,6,3,2,4 };
  for (auto& x : arr)
  {
    x * 2;
  }

【注意】

for循环迭代的范围必须是确定的

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