目录
前言
C++背景
C语言是结构化和模块化的语言，适合处理较小规模的程序。对于复杂的问题，规模较大的程序，需要高度的抽象和建模时，C语言则不合适。为了解决软件危机， 20世纪80年代，计算机界提出了OOP(object oriented programming：面向对象)思想，支持面向对象的程序设计语言应运而生。1982年，Bjarne Stroustrup博士在C语言的基础上引入并扩充了面向对象的概念，发明了一种新的程序语言，为了表达该语言与C语言的渊源关系，命名为C++。
因此：C++是基于C语言而产的，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计。
C++是一个重范性编程语言，其包括四个次语言：C，Object-Oriented C++、Template C++和STL；C++内容丰富多彩，所以也难以掌握，掌握C++需要不屑的努力！
C++的发展史
1979年，贝尔实验室的本贾尼等人试图分析unix内核的时候，试图将内核模块化，于是在C
语言的基础上进行扩展，增加了类的机制，完成了一个可以运行的预处理程序，称之为C with classes。语言的发展就像是练功打怪升级一样，也是逐步递进，由浅入深的过程。
阶段 内容 C with
classes类及派生类、公有和私有成员、类的构造和析构、友元、内联函数、赋值运算符
重载等C++1.0 添加虚函数概念，函数和运算符重载，引用、常量等 C++2.0 更加完善支持面向对象，新增保护成员、多重继承、对象的初始化、抽象类、静
态成员以及const成员函数C++3.0 进一步完善，引入模板，解决多重继承产生的二义性问题和相应构造和析构的处
理C++98 C++标准第一个版本，绝大多数编译器都支持，得到了国际标准化组织(ISO)和美
国标准化协会认可，以模板方式重写C++标准库，引入了STL(标准模板库)C++03 C++标准第二个版本，语言特性无大改变，主要：修订错误、减少多异性 C++05 C++标准委员会发布了一份计数报告(Technical Report，TR1)，正式更名
C++0x，即：计划在本世纪第一个10年的某个时间发布C++11 增加了许多特性，使得C++更像一种新语言，比如：正则表达式、基于范围for循
环、auto关键字、新容器、列表初始化、标准线程库等C++14 对C++11的扩展，主要是修复C++11中漏洞以及改进，比如：泛型的lambda表
达式，auto的返回值类型推导，二进制字面常量等C++17 在C++11上做了一些小幅改进，增加了19个新特性，比如：static_assert()的文
本信息可选，Fold表达式用于可变的模板，if和switch语句中的初始化器等C++20 自C++11以来最大的发行版，引入了许多新的特性，比如：模块(Modules)、协
程(Coroutines)、范围(Ranges)、概念(Constraints)等重大特性，还有对已有
特性的更新：比如Lambda支持模板、范围for支持初始化等C++23 制定ing 其中C++98，C++11和C++20这三个版本的改动比较大，也是我们后面学习会提及的！
正文
C++是在C的基础之上，容纳进去了面向对象编程思想，并增加了许多有用的库，以及编程范式等。熟悉C语言之后，对C++学习有一定的帮助；正式进入C++的学习之前，我们需要了解C++补充C语言语法的不足的地方，以及C++是如何对C语言设计不合理的地方进行优化的，比如：作用域方面、IO方面、函数方面、指针方面、宏方面等；这样才能为后面的C++学习打下基础！
C++关键字(C++98)
C语言有32个关键字，C++总计有63个关键字，C++在C的基础上增加了31个关键字！
asm do if return try continue auto double inline short typedef for bool dynamic_cast int signed typeid public break else long sizeof typename throw case enum mutable static union wchar_t catch explicit namespace static_cast unsigned default char export new struct using friend class extern operator switch virtual register const false private template void true const_cast float protected this volatile while delete goto reinterpret_cast 这么多关键字我们一开始只需要了解，后面会逐渐介绍和使用！
C++的输入输出和头文件
C++输入输出的使用
在C语言中我们常使用scanf格式化输入，printf格式化输出！在C++中我们依然可以使用scanf和printf因为C++兼容C，但是一般我们使用的是cin和cout！
#include<iostream> //iostream类库IO流头文件 using namespace std; //全局展开std标准库命名空间 int main() { int n = 0; char ch = 0; cin >> ch; //流提取运算符 cin >> n; cout << "Hello Word!\n"; cout << ch << " = " << n << endl; //流插入运算符 return 0; }
代码运行展示 首先在输入输出上C++就进行了优化，我们可以不指定格式就输入输出，这个运用了函数重载实现，我们后期会讲到！
对于cin和cout的说明
1. 使用cout标准输出对象(控制台)和cin标准输入对象(键盘)时，必须包含< iostream >头文件以及按命名空间使用方法使用std。
2. cout和cin是全局的流对象，endl是特殊的C++符号，表示换行输出，他们都包含在包含<
iostream >头文件中。cin提取内容时碰到空格和换行时结束。不过在cout中也可以使用“\n”(双引号括上\n)换行。
3.<<是流插入运算符，配合cout使用，让变量值流向cout然后进行输出；>>是流提取运算符，配合cin使用，让输入的数据流向变量进行赋值。
4. 使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动控制格式。
C++的输入输出可以自动识别变量类型。
5. 实际上cout和cin分别是ostream和istream类型的对象，>>和<<也涉及运算符重载等知识，这些知识我们我们后续才会学习，所以我们这里只是简单学习他们的使用。
C++头文件的包含方式
早期标准库将所有功能在全局域中实现，声明在.h后缀的头文件中，使用时只需包含对应
头文件即可，后来将其实现在std命名空间下，为了和C头文件区分，也为了正确使用命名空间，规定C++头文件不带.h；旧编译器(vc 6.0)中还支持<iostream.h>格式，后续编译器已不支持，因此推荐使用<iostream>+std的方式！
对于std命名空间的展开方式和使用，下面马上就会介绍最合适的使用方式！
命名空间
命名空间的意义
命名空间在许多面向对象的语言中都支持，其地位显而易见非常重要！
命名空间的诞生意义是在C/C++中，变量、函数和类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。
例如，两个项目组同时开发一种功能，最后进行性能测试时发现两组开发的项目代码中有许多变量和函数甚至是类的命名相同，此时编译不通过，使用命名空间后就可以解决这个问题！
将代码块写入命名空间中，使用时指定命名空间进行使用就可以避免这个问题！
命名空间的定义
定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{ }中即为命名空间的成员！
namespace 命名空间名 {命名空间成员} //格式#include<iostream> using namespace std; namespace A //定义A命名空间 { const char* str = "A命名空间！";//A空间成员str } namespace B //定义B命名空间 { const char* str = "B命名空间！";//B空间成员str } int main() { cout << A::str << endl; cout << B::str << endl; // :: 是域作用访问限定符，指定访问的空间 return 0; }
命名空间的使用和展开
全局展开
using namespace 命名空间; //格式 //例如 using namespace std; //全局展开标准库命名空间 using namespace A;//全局展开A命名空间 using namespace B;//全局展开B命名空间此时我们就知道了 using namespace std； 这句代码的意思了，这句代码是全局展开std标准库命名空间，展开了std命名空间，我们才能使用 cin，cout 和 endl 。在平时使用时我们不建议这样全局展开某个命名空间，因为这样做命名空间就失去了意义，相当于没有命名空间！不过在日常写小型程序时，可以局部展开方便使用！
局部展开
using 命名空间::命名空间成员; //格式 //例如 using std::cout; //只展开std命名空间中cout对象 using A::str; //只展开A命名空间中str字符串局部展开方式，可以让我们只展开自己需要的命名空间成员(变量，函数和类等)使用即可！这样就避免了全局展开的不足！一般如果某个命名空间成员需要经常使用，此时我们推荐使用局部展开的方式展开该成员！
作用域限定符指定成员
命名空间::命名空间成员 //格式 //例如 std::cout<< A::str << std::endl; //使用时展开命名空间成员 ::cout<< B::str << ::endl; //如果::操作符没有指定命名空间，则编译器会去全局查找作用域限定符指定成员的方式，在平时也会使用，但是没有局部展开使用的多，某些情况下，如果成员使用较少，或者只有这一次，可以使用作用域限定符指定成员的方式！
注意：命名空间可以嵌套使用！但是命名空间之间不能同名，如果命名空间同名编译器会将两个命名空间合并，此时如果两个命名空间成员有同名的情况，编译器就会报错！
缺省参数
定义和使用
缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参。相当于设置了一个默认值！
#include<iostream> using namespace std; void Print(int num = 0) { cout << num << endl; } int main() { Print(6); //传递参数6 Print(); //不传递参数 return 0; }
带有缺省参数的函数，在调用时可以给予参数也可以不给予，如果给予参数则函数参数为指定的参数，否则为默认的缺省参数！
注意事项
C语言不支持缺省参数，在C语言中使用缺少参数会报错！
缺省值一般为常量或者全局变量，也允许使用表达式，所以也可以是全局变量或者函数返回值。但是缺省值不能是局部变量或者非静态成员函数的返回值，也不能是this。缺省值的表达式中也不能引用其它参数。
缺省参数有两种形式：全缺省参数和半缺省参数！
全缺省参数
void Fun(int a = 0,int b = 0,int c = 0); //全缺省参数缺省值必须是常量或者全局变量！
半缺省参数
void Fun(int a,int b = 0,int c = 0); //半缺省参数 void Fun(int a,int b,int c = 0); //半缺省参数半缺省参数必须从右往左依次连续给出，不能间隔着给！
//定义或声明错误演示 int Fun(int a = 0, int b, int c); int Fun(int a = 0, int b, int c = 0); int Fun(int a = 0, int b = 0, int c); //这三种半缺省参数写法都是错误的！！！//调用时错误演示 int Fun(int a, int b = 0, int c = 0); int main() { Fun(); //半缺省时至少给出未缺省参数的值 Fun(1 , , 3); //不能使用逗号跳跃给缺省值 returm 0 }//正确演示 int Fun(int a, int b, int c = 0) //半缺省参数必须从右开始连续缺省，不能跳跃缺省 { return a + b + c; } int main() { //调用时实参依次从左至右开始传递 cout << Fun(1, 2) << endl; //使用缺省参数 cout << Fun(1, 2, 3) << endl; //不使用缺省参数 return 0; }缺省参数不能在函数声明和定义中同时出现
//错误演示 int Fun(int a = 0, int b = 0, int c = 0); //声明 int Fun(int a = 0, int b = 0, int c = 0) //定义 { return a + b + c; } //这种写法是错误的，编译器会报错！ //如果带有缺省参数的函数声明与定义分离，缺省参数只写在声明中！
函数重载
概念和定义
函数重载是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数 , 类型 或 类型顺序)不同，常用来处理实现功能类似数据类型不同的问题。
//示例 int add(int a,int b) //定义函数参数为int类型 { return a+b; } double add(double a,double b) //定义函数参数为double类型 { return a+b; } int main() { //两个add函数构成1重载 cout<<add(1,2)<<endl; cout<<add(1.11,2.22)<<endl; return 0; }
构成函数重载的条件
函数重载的所有函数必须在同一个作用域中，同时满足以下条件构成重载：
1、参数类型不同
//示例 void Fun(int i); void Fun(double d); void Fun(char c); //以上函数构成重载
2、参数个数不同//示例 void Fun(int a); void Fun(int a,int b); void Fun(int a, int b, int c); //以上函数构成重载
3、参数类型顺序不同//示例 void Fun(int a,char c); void Fun(int c,char a); //以上函数构成重载
实现原理
C++函数重载的原理是编译器对函数名进行修饰！
其修饰规则是：_Z+函数名长度+类型+从左到右参数类型首字母
//示例 int add(int a,int b); //修饰后的函数名为_Z3addii double add(double a,double b); //修饰后的函数名为_Z3adddd
演示来自Linux环境 在Linux下通过 objdump -S 指令对可执行程序进行反汇编可以看到C++和C语言在函数名修饰上的区别，如果是在VS环境下，原理相同，但是由于封装的更好无法进行更明显的观察，上面C++函数名在VS中被修饰为 ?add@@YAHHH@Z 和 ?add@@YANNN@Z ，现阶段我们无法通过简单的规律去判别，所以一般要验证还是去Linux进行查看！
在C++进行函数名修饰后并入符号表，如果在编译链接时修饰后的函数名没有与其他函数冲突就能正常运行！
注意事项
函数返回值不同不构成重载
//错误示例 int add(int a,int b); double add(int a,int b); //以上函数不构成重载函数形参类型相同位置调换不构成重载
//错误示例 int add(int a,int b); int add(int b,int a); //以上函数不构成重载由函数重载的原理，以上情况不能构成重载！
引用
引用的概念和定义
引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。
在C语言中如果我们想对一个变量在另一个函数中进行修改需要取该变量的地址，使用指针进行修改，这样的操作既危险又麻烦，于是C++产生了引用类型！
引用类型相当于引用实体(被引用对象)的别名，你就是我我就是你，我的改变可以引起你的改变！
//引用 使用格式 类型& 变量名 = 引用对象; //示例 int a = 0; int& b = a; //b是a的引用，b就是a，a就是b//示例代码 int main() { int a = 0; cout << a << endl; int& rb = a; rb = 5; cout << a << endl; int* pc = &a; *pc = 3; cout << a << endl; return 0; }
显然，引用类型在这里的优势明显，如果使用指针还需要进行解引用，而且有野指针的风险！
引用类型在底层上是用指针实现的，理论上应该要占栈帧空间的，但是编译器中引用变量是不占空间的，使用sizeof对引用类型求字节数所得大小是被引用对象的大小！
#include<iostream> using namespace std; typedef struct Test //自定义结构体类型 { int a; int b; char c; long d; }T; int main() { T t;//创建结构体对象 T& x = t; //引用结构体对象 cout << sizeof(t) << endl; //求结构体对象大小 cout << sizeof(x) << endl; return 0; }
可以发现，如果理论上是指针实现的，大小应该为4字节，但是引用对象的大小却是被引用对象的大小！
引用的使用规范
1.引用对象的类型必须与被引用对象类型相同。
2.引用在定义时必须初始化(必须引用一个变量或对象)，而且不能为空。
3.一个变量可以有多个引用，但一个引用变量只能引用一个对象，不能进行修改。
4.多级引用的最终引用对象还是最初被引用的对象(例如b引用a，c引用b，那么c引用的其实还是a)，一般平时不建议这样多级引用。
//错误示例 int a = 0; char c = 'c'; char h = 'h'; //引用类型与被引用对象类型不同 double& b = a; //这是错误的引用，类型不匹配 //引用类型变量没有初始化，或赋值空指针 int& b; //引用不初始化 int& c = nullptr; //引用变量赋值空指针 //引用多个对象-引用不能像指针那样指向同类型的不同地址 char& s = c;//引用变量一旦初始化指定引用对象后就不能修改 char& s = h;//不能修改引用对象//多级引用 int a = 0； int& b = a; //b引用a int& c = b; //c引用b，b本质上是引用a，所以c相当于引用a int& d = c; //d引用c，相当于引用a //无论怎么套娃最终引用对象还是最初的被引用对象
常引用
对于引用类型的变量来说，因为可以修改原对象，如果原对象是常量那么编译就会报错！
//错误示例 const int num = 0; int& a = num; //引用const修饰的变量 int* pa = # //使用指针指向常量 int& b = 10; //直接引用常量对于一个程序来说，空间大小划分为栈，堆，静态区等，常量一般存在于数据段或代码段这些只读空间上，是没有修改权限的，使用引用和指针对常量都会发生权限放大的问题，使本来没有写权限的变量有了写权限，这是不被系统允许的！编译时也会发生错误！
正确的使用方法，应该是对引用类型(或指针类型)使用const修饰，使其为常引用(或常量指针)，实现权限平移！
//正确示例 const int num = 0; //num被const修饰具有常性 const int& a = num; const int* pa = # const int& b = 10;
引用类型返回值
引用类型的方便之处不仅仅是做函数的引用参数，还可以做返回值！
#include<iostream> using namespace std; int arr[10] = { 0 }; int& TraveArr(int sub) //在这种场景下使用引用返回非常合适 { return arr[sub]; } int main() { for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i) { TraveArr(i) = i + 1; } for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i) { cout << TraveArr(i) << " "; } cout << endl; return 0; }
几乎以前80%使用指针的场景都可以换为引用，但是部分场景下还是需要指针，所以C++完成项目时一般是指针和引用混合搭配使用！
错误使用引用返回值
//错误示例 #include<iostream> using namespace std; int& add(int a, int b) { int c = a + b; //c是add函数栈帧的变量，add函数结束就销毁了 return c; //如果把c变量作为引用类型返回则会出现类似野指针的问题 } void Print(){ } int main() { int& a = add(1, 2);//此时接收的返回值在没有函数栈帧变化的情况下是正常的 cout << a << endl; cout << a << endl; int& b = add(2, 3);//一旦涉及函数栈帧的变化就会造成随机值 cout << b << endl; Print(); cout << b << endl; return 0; }
不能将其他函数的临时变量作为引用类型传递给调用函数，这样相当于野指针访问！
引用返回的优点在于减少了拷贝次数，在后面自定义类型做返回值时使用引用类型可以提供性能，在某些场景下传引用返回比传值返回要好很多！
引用与指针的不同
1. 引用概念上定义一个变量的别名，指针存储一个变量地址。
2. 引用在定义时必须初始化，指针没有要求。
3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体。
4. 没有NULL引用，但有NULL指针。
5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)。
6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小。
7. 有多级指针，但是没有多级引用。
8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理。
9. 引用比指针使用起来相对更安全。
引用与指针互不冲突，在常规领域下引用占优势，在特殊情况下，例如链表需要修改指向时必须使用指针。所以在以后的使用中以引用为主，特殊情况下才使用指针！
内联函数
概念和定义
在对于一些常用的值或者函数，我们可能会使用宏定义去实现然后调用，这样方便修改。
宏定义的优缺点
优点：
1.增强代码的复用性。
2.提高性能。缺点：
1.不方便调试宏。（因为预编译阶段进行了替换）
2.导致代码可读性差，可维护性差，容易误用。
3.没有类型安全的检查很多书籍和专业人士建议尽量避免使用宏定义！建议使用const和enum代替宏定义的常量，使用内联函数替换宏函数！
宏定义的有非常好的优点，但是缺点是刀刀致命，，为了能使用宏定义的优点但是又避免宏定义的缺点，C++语法规定了内联函数。
inline 返回值类型 函数名(参数) //格式 { //定义 }将函数修饰为内联函数，那么在debug模式下没有然后变化，但是如果使用realse模式则编译器会将内联函数在调用处展开以提高性能！
注意事项
1. inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用，缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运行效率。所以内联函数一般用于被频繁调用的小函数。
2. inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。所以内联函数最终是否在调用处展开取决于编译器的决定！
3. inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。如果存在头文件声明，因为内联函数不记入符号表，所以内联函数一般建议直接定义在头文件的声明处，让头文件将内联函数一起包含。
auto关键字(C++11)
使用背景
我们在写一些小项目时，不妨会使用自定义类型，例如结构体，又或者是C++的类；在定义类型时会碰到类型名很长或者说不知道什么类型的情况。这说明随着我们学习的深入会出现：类型难于拼写或者含义不明确导致容易出错的情况！
此时可能有朋友会想到如果类型名很长使用typedef不就行了，但是typedef也会遇到一些问题：
#include<iostream> using namespace std; //typedef的不足 typedef char* pstring; int main() { const pstring p1; // 编译不通过，该变量没有初始化赋值为常量 const pstring p1 = nullptr; // 正确的写法 //对于下面的语句const修饰pstring*，而p2是pstring**二级指针，所以编译可以通过 const pstring* p2; return 0; }这段错误代码，很明显的展示了typedef的不足，因此C++11给auto赋予了新的含义！
auto的使用
在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，但遗憾的是一直没有人去使用它！
C++11中，标准委员会赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。auto 变量名 = 已定义变量/常量; //格式#include<iostream> using namespace std; int main() { int a = 0; auto b = a; cout << typeid(b).name() << endl; char c = 'c'; auto h = c; cout << typeid(h).name() << endl; int* p = &a; auto pp = p; cout << typeid(p).name() << endl; return 0; } //typeid(变量名).name() 是获取变量类型并以字符串形式打印出来的对象库函数
这里借助typeid(变量名).name()对象库函数打印变量的类型，发现auto可以精确的推断所赋值对象的类型！
注意事项
使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为变量实际的类型。
1. auto与指针和引用结合起来使用用auto声明指针类型与用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&。
#include<iostream> using namespace std; int main() { int x = 10; auto a = &x; //取地址赋值给a auto* b = &x;//去地址赋值给指针b auto& c = x; //引用类型引用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在同一行定义多个变量
当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译
器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。#include<iostream> using namespace std; int main() { auto a = 1, b = 2; auto c = 3, d = 4.0; // 该行代码会编译失败，因为c和d的初始化表达式类型不同 return 0; }auto不能作为函数参数和声明数组
//错误示例 void Test(auto num) {} //这样声明编译器会报错 int main() { int a[] = {1,2,3}; auto b[] = {1,2,3}; //该语句编译器会报错无法识别类型 return 0; }
为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法，auto在实际中最常见的优势用法就是跟的C++11提供的新式for循环，还有lambda表达式等进行配合使用！
基于范围的for循环(C++11)
范围for的语法
在C++98中如果要遍历一个数组，可以按照以下方式进行：
#include<iostream> using namespace std; int main() { int array[] = { 1, 2, 3, 4, 5 }; for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i) { array[i] *= 2; } for (int* p = array; p < array + sizeof(array)/ sizeof(array[0]); ++p) { cout << *p << endl; } }对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。
for(数据类型 迭代变量 : 迭代范围(迭代对象)) {迭代语句} //格式//示例 #include<iostream> using namespace std; int main() { int array[] = { 1, 2, 3, 4, 5 }; for (auto& e : array) { e *= 2; } for (auto e : array) { cout << e << " "; } return 0; }
范围for使用条件
for循环迭代的范围必须是确定的，迭代的对象要实现++和==的操作(与类对象相关的范围for迭代)，对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供begin和end的方法，begin和end就是for循环迭代的范围。
//错误示例 #include<iostream> using namespace std; void Print(int array[]) { for(auto& e : array) //这里for会报错 { cout<< e <<endl; } } int main() { int arr[] = {1,2,3,4,5}; Print(arr); return 0; }
指针空值nullptr
C++98中的指针空值
在良好的C/C++编程习惯中，声明一个变量时最好给该变量一个合适的初始值，否则可能会出现不可预料的错误，比如未初始化的指针。如果一个指针没有合法的指向，我们基本都是按照如下方式对其进行初始化：
#include<iostream> using namespace std; int main() { int* p1 = NULL; int* p2 = 0; return 0; }NULL实际是一个宏，在传统的C头文件(stddef.h)中，可以看到如下代码:
#ifndef NULL #ifdef __cplusplus #define NULL 0 #else #define NULL ((void *)0) #endif #endif可以看到，NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量。不论采取何种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦，比如:
#include<iostream> using namespace std; int main() { cout << typeid(0).name() << endl; cout << typeid(NULL).name() << endl; cout << typeid((int*)NULL).name() << endl; return 0; }
程序本意是想通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义成0，因此与程序的初衷相悖。在C++98中，字面常量0既可以是一个整形数字，也可以是无类型的指针(void*)常量，但是编译器默认情况下将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转(void*)0。
nullptr解决方案
由于这种情况，推委会推出了nullptr这个补丁，补全了指针初始化为空指针的空缺！
nullptr //在C++中以后初始化指针为空使用该值//示例 #include<iostream> using namespace std; void Test(int* p) { cout << typeid(p).name() << endl; } void Test(int p) { cout << typeid(p).name() << endl; } int main() { auto ptr = nullptr; Test(ptr); return 0; }
nullptr被识别为指针类型
注意事项
1. 在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的。
2. 在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。
3. 为了提高代码的健壮性，从C++开始表示指针空值时建议最好使用nullptr。
最后
关于C++入门知识的介绍到这里就告一段落了。学习了这些C++入门前的基础知识，我们可以发现C++在入门前补缺了一些C的不足，特别是 函数重载，引用类型，auto 等新特性非常强大，这也为后面C++面向对象式编程的正式学习打下了基础，C++学习之路很长，我们都是追梦人！
本次C++入门知识就介绍到这里啦，希望能够尽可能帮助到大家。
如果文章中有瑕疵，还请各位大佬细心点评和留言，我将立即修补错误，谢谢！
🌟其他文章阅读推荐🌟
🌹欢迎读者多多浏览多多支持!🌹
333
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
