[C++]入门学习的前言与内容的讲解分析
- 引言
- 一、C++学习前言
- 1.1、什么是C++
- 1.2、C++发展史
- 1.3、C++学习的重要性
- 1.3.1语言的使用广泛
- 1.3.2在工作领域
- 1.3.3招聘需求
- 二、C++入门知识
- 2.1、C++关键字
- 2.2、命名空间
- 2.2.1引言
- 2.2.2命名空间的定义
- 2.2.3命名空间的使用
- 2.3、C++输入&输出
- 2.4、缺省参数
- 2.4.1全缺省参数
- 2.4.2半缺省参数
- 2.5、函数重载
- 2.5.1名字修饰
- 2.5.2return "C"
- 2.6、引用
- 2.6.1应用的特性
- 2.6.2常引用
- 2.6.3 使用场景
- 2.6.3.1做返回值
- 2.6.3.2做参数
- 2.6.4引用&传值的效率比较（了解）
- 2.6.5引用&指针的比较（了解）
- 2.7、内联函数
- 2.8、auto关键字（C++11）
- 2.9、基于范围的for循环（C++11）
- 2.10、指针空值——nullptr（C++11）
- 总结
引言
相信我们这些接触过计算机的学生，都或多或少听过C++这一门语言，我们或多或少有过一些想法，C++是什么？是C语言的升级吗？还是说是一门全新的语言？C++难学么？上述的内容在我接触C++之前也有过思考，在这里我们就话不多数，将更多的精力花在实实在在的知识方面的学习，下面然我们开始我们的C++学习之旅。
一、C++学习前言
1.1、什么是C++
①C语言是结构化和模块化的语言，适合处理较小规模的程序。对于复杂的问题，规模较大的程序，需要高度的抽象和建模时，C语言则不合适。为了解决软件危机， 20世纪80年代， 计算机界提出了OOP(objectoriented programming：面向对象)思想，支持面向对象的程序设计语言应运而生。
②1982年，Bjarne Stroustrup博士在C语言的基础上引入并扩充了面向对象的概念，发明了一种新的程序语言。为了表达该语言与C语言的渊源关系，命名为C++。因此：C++是基于C语言而产生的，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计。
③换一句话说，C++的创建就是补充C语言中没有的内容，同时更加方便的使用一些库函数，省去了我们C语言时期的“什么都要自己造”的时代。
1.2、C++发展史
或许我们会对C++的发展史有所忽略，但如果我们可以了解跟多关于C++的内容，那么我们在学习或者理解相关知识的时候会对我们有一些潜在的帮助，比如C++一些重要的内容的加入，使得C++一直热度不减，直到现在一直保持着编译语言前三名。
| 阶段 | 内容 |
|---|---|
| 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 | 令人失望 |
1.3、C++学习的重要性
我们这里简单的几个方面介绍一下C++的重要性
1.3.1语言的使用广泛
今年的开发语言排行榜的情况：
1.3.2在工作领域
我们随意举一些需要用到C++方面的工作岗位：
①操作系统以及大型软件开发
②人工智能
③网络开发
④游戏开发
⑤嵌入式领域
…………
1.3.3招聘需求
岗位的需求与要求：
①华为
②腾讯：
③网易：
二、C++入门知识
2.1、C++关键字
我们在C语言中学习了32个关键字，既然C++是对C语言内容的补充和添加，那么C++中也含有关键字，其中就包括C语言中的关键字，一共63个关键字。
| 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 |
2.2、命名空间
2.2.1引言
相信你在学习的过程中一定遇到过这样的情况，就是我们明明只是想实现一个交换的功能，但却因为要交换的数据类型不同，导致我们在C语言中需要将统一功能的函数命名为不同的函数名；又或者在工作中或者小组作业中，每个人都被分配了任务，但两个人之间的函数名可能重名，那么这个时候就需要一个人去修改自己的程序，如果这个很大，很复杂，那么就会很繁琐，让人头痛，而C++就考虑了这个问题，而其为了解决这个问题，C++中就有了“命名空间”这个定义。
2.2.2命名空间的定义
①
在C语言中，一个工程的建立我们可能需要创建大量的变量、函数、类等，而这些内容都将存在于全局域中，而这可能会导致冲突，而命名空间的出现，就可以避免命名冲突、名字污染等情况，命名空间的出现可以对标识符的名称进行本地化，namespace 关键字的出现就可以针对这个问题并且解决。
②
定义命名空间时，我们现在知道需要namespace这个关键字，后面更加命名空间的名字，然后像创建一个函数一样，用{}进行内容的包裹，而这其中的内容就是命名空间的成员。
③
一个命名空间就相当于定义了一个新的作用域，命名空间中的所有内容都局限于命名空间中
④代码：
④—①命名空间中可以定义变量和函数
namespace hzh
{
int a = 10;
int b = 20;
int Add(int x, int y)
{
return x + y;
}
}
④—②命名空间中可以嵌套定义命名空间
namespace lzy//命名空间一：lzy
{
int a;
int b;
namespace csz//命名空间二：csz
{
int Sub(int x, int y)
{
return x - y;
}
}
}
④—③同一个工程中允许存在多个相同的命名空间，编译器在最后会合成同一个命名空间中
namespace hzh//在一个工程中的头文件中定义hzh这个命名空间
{
struct Stack
{
int* a;
int size;
int capacity;
};
}
namespace hzh//在③—①中我们定义的命名空间
{
int a = 10;
int b = 20;
int Add(int x, int y)
{
return x + y;
}
}
//在一个工程中我们允许多次对同一个命名空间进行定义
2.2.3命名空间的使用
①引言
我们通过上面的学习知道了如何定义一个命名空间，那么命名空间应该如何使用呢？我们先来看一段代码。
#include<stdio.h>
#include<stdlib.h>
namespace hzh
{
int a = 20;
int b = 10;
int Add(int x, int y)
{
return x + y;
}
}
int main()
{
printf("%d", a);
return 0;
}
你觉得这里程序可以成功运行吗？让我们来看看运行结果。
这里就体现了我们在上一小结中的一句话:
一个命名空间就相当于定义了一个新的作用域，命名空间中的所有内容都局限于命名空间中
那么如果我们想要将命名空间hzh中的变量a进行打印，那么我们应该进行什么操作呢？
这里我们就引出我们的命名空间的使用。
②命名空间的使用方式：
方式1.使用using namespace命名空间名称，实现引入
代码：
#include<stdio.h>
#include<stdlib.h>
namespace hzh
{
int a = 20;
int b = 10;
int Add(int x, int y)
{
return x + y;
}
}
using namespace hzh;//这里关键字using的使用将我们的hzh命名空间进行展开，展开到全局作用域中，这样我们可以直接使用我们命名空间中的内容
int main()
{
printf("%d", a);
return 0;
}
方式2.使用命名空间名称+作用域限定符：：，实现引入
代码：
#include<stdio.h>
#include<stdlib.h>
namespace hzh
{
int a = 20;
int b = 10;
int Add(int x, int y)
{
return x + y;
}
}
int main()
{
printf("%d\n",hzh::a);//作用域限定符:: 这里我们可以理解为"::"的使用，让我们在hzh这个命名空间中找到了a这个变量，这个时候我们就可以将其打印
return 0;
}
方式3.使用using将命名空间中的成员引入
代码：
#include<stdio.h>
#include<stdlib.h>
namespace hzh
{
int a = 20;
int b = 10;
int Add(int x, int y)
{
return x + y;
}
}
using hzh::a;//这里我们可以理解为我们将hzh这个命名空间中变量a释放，将其的作用域展开到全局作用域中，从而可以被我们调用实现打印
int main()
{
printf("%d", a);
return 0;
}
2.3、C++输入&输出
我们在学习C语言时，第一句学习的代码相信都是“hellow world”，那么我们在C++这门编译语言中，我们应该如何实现这句代码呢？如果实现，那它和C语言有什么区别呢？下面让我们先看实现的代码，然后我们再进行分析。
代码：
#include<iostream>
using namespace std;
int main()
{
cout << "Hellow world" << endl;
return 0;
}
运行结果：
这里我们进行分析与知识点的讲解：
①
我们使用cout标准输出（控制台）和cin标准输出（控制台）时，必须包含头文件以及std标准命名空间。
②
cin就相当于我们C语言中的输出，结合>>(可以想象为从左侧进行向内输入)；
cout就相当于我们C语言中的输入,结合<<(可以想象为从左侧进行向外输出)；
③早期标准库将所有功能在全局域中实现，声明在.h后缀的头文件中，使用时只需包含对应头文件即可，后来将其实现在std命名空间下，为了和C头文件区分，也为了正确使用命名空间，规定C++头文件不带.h；旧编译器(vc 6.0)中还支持<iostream.h>格式，后续编译器已不支持，因此推荐使用+std的方式。
④
我们在C++中进行输入输出时，是不需要考虑数据的类型的
代码：
#include<iostream>
using namespace std;
int main()
{
int a;
double b;
char c;
cin >> a;
cin >> b >> c;
cout << a << endl;
cout << b << " " << c << endl;
return 0;
}
代码分析：
2.4、缺省参数
①引言：
在C语言中，我们建立函数时，设置的形参只有实参传参之后我们才能成功调用函数，而C++中我们即使没有传参，这个函数我们也可以调用，但这个调用时，我们使用的参数是我们一开始设置的参数，又叫做缺省参数，而如果我们传入我们的参数，那么这个之前默认的参数就作废了，就和上面的图片一样，是个备胎。
②缺省参数的定义：
缺省参数是声明或者定义函数时为函数的参数指定一个默认值，在调用函数的时，如果没有指定实参则采用该默认值，否则使用指定的实参。
③举例与分析：
代码一：
#include<iostream>
using namespace std;
void Test(int a = 0)
{
cout << a << endl;
}
int main()
{
Test();
Test(10);
return 0;
}
分析：
④缺省参数的分类：
2.4.1全缺省参数
在定义函数时，所有参数我们都将其设置为缺省参数
void Test(int a = 10; int b = 20; int c = 30)
{
cout << "a = " << a << endl;
cout << "a = " << b << endl;
cout << "a = " << c << endl;
}
2.4.2半缺省参数
在定义函数时，我们将函数中的部分参数设置为缺省参数
void Test(int a; int b; int c = 30)
{
cout << "a = " << a << endl;
cout << "a = " << b << endl;
cout << "a = " << c << endl;
}
⑤注意：
1.在函数中设置缺省参数时，其必须从左到右设置，不能间隔设置
错误代码：
void Test(int a=10; int b; int c = 30)
{
cout << "a = " << a << endl;
cout << "a = " << b << endl;
cout << "a = " << c << endl;
}
因为这样我们在传参时，实参我们只输入了一个数字，那么这个数字传递给那个形参编译器无法判断
2.缺省参数不能在函数声明和定义中同时出现，这里这样定义是因为防止在声明和定义时，两处函数中缺省参数设置的数值不同，这样编译器就无法确定到底使用哪一个缺省值。
代码如下：
//test.h
void Test(int a = 10);
//test.cpp
void Test(int a = 20)
{}
int main()
{
Test();
return 0;
}
运行结果：
3.缺省值必须是常量或者全局变量
4.C语言不支持
2.5、函数重载
①引言
在西游记中我们知道有真假美猴王这一情节，这里我们从另一方面看待真假美猴王，他们都可以实现变身，也都有武器，也就是说他们可以实现相同的功能，但从另一方面来看，他们的区别似乎只有自身的种类不同，一个是灵明石猴，一个是六耳猕猴；而这样的情况在C++中也是存在的，这种情况就是C++中的函数重载。
②概念
函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数 或 类型 或 顺序)必须不同，常用来处理实现功能类似数据类型不同的问题
③举例分析
代码如下：
int Add(int a, int b)
{
return a + b;
}
int Add(int a, double b)
{
return a + b;
}
double Add(double a, double b)
{
return a + b;
}
分析：
上面代码中的Add函数就是函数的重载，因为上面举例的代码中每一个Add函数中参数的类型都不完全相同，当我们在main函数中调用时，其会根据我们传入的参数来自动判断比较选择想对应的函数
2.5.1名字修饰
①引言
为什么C语言不支持函数的重载而C++支持函数的重载呢？
②引言解答
在这里我们进行一个简单的回答，因为如果在这里进行展开讲解的话，一篇两万字左右的博客可能才可以彻底讲清楚，所以这里我们进行一个简单的回答，最主要的目的是告诉我们为什么C语言不支持函数的重载而C++支持函数的重载，以及引出名字修饰的内容
代码：
int Add(int a, int b)
{
return a + b;
}
int Add(int a, double b)
{
return a + b;
}
分析：
这里我们对上面的代码在不同的环境下进行分析：
当我们在C的环境中时，我们通过编译的一些方式可以获得如下内容
当我们在C++的环境中时，我们通过编译的一些方式可以获得如下内容
这里我们可以发现：在C++的环境中，函数名字的修饰发生了改变，编译器将函数参数的类型信息添加到了修改后的函数名中
这也就是为什么C语言环境中不支持函数重载而C++环境中支持函数重载的原因，同时上述的情况对比我们简单了解了函数名字修饰的情况，在后面我写一篇博客，对这一小结内容进行更加详细的内容分析
2.5.2return “C”
①引言
我们知道C++的出现是为了对C的内容进行补充和修改完善，有时候我们在C语言环境的程序中使用C++的某些内容是比较高效的，但我们又知道C++是对C兼容的，但C对C++环境并不兼容，那么这个时候我们该怎么办？ 这里我们在函数前加extern "C"就可以解决这个问题
②图解分析
2.6、引用
①引言
在生活中，我们每个人在儿时都有自己的小名，和朋友之间也有自己专属的外号，而这一现象并不是只有在生活中才有，在C++中我们也有相同的情况，但C++中这样的情况却另有他用。
②概念
引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。
③举例分析
代码：
void Test()
{
int a = 10;
int& b = a;
}
分析：
代码：
#include<iostream>
using namespace std;
void Swap(int&rx, int&ry)
{
int temp = rx;
rx = ry;
ry = temp;
}
int main()
{
int x = 0, y = 1;
Swap(x, y);
return 0;
}
分析：
2.6.1应用的特性
①引用在定义时必须初始化
正确代码：
void Test()
{
int a = 10;
int& ra = a;
}
错误代码：
void Test()
{
int a = 10;
int& rb;//这里的&rb是无效定义，因为这里编译器不知道你要对谁进行取别名；
int& ra = a;
}
②一个变量可以有多个引用
void Test()
{
int a = 10;
int& ra = a;
int& rra = a;
int& rrra = a;
}
③引用一旦引用一个实体之后，就再不能引用其他实体
void Test()
{
int a = 10;
int b = 20;
int& ra = a;
int& rb = b;
int&rb = a;//这里我们已经对b取别名为rb，此时再对a取别名rb后，编译器无法识别rb到底是哪一个变量的别名，所以引用一旦引用一个实体之后，就再不能引用其他实体。
}
2.6.2常引用
现在我们分析这一段代码
int main()
{
int i = 10;
double d = i;
double&r = i;
}
当我们执行这一段代码时，编译器报错
说明这里第三行代码"double&r = i"错误，但我们这个时候发现 int类型的i都可以赋值给double类型的变量d，那为什么不可以对int类型的变量取double类型的别名呢？
下面是可以成功执行的代码
int main()
{
int i = 10;
double d = i;
const double&r = i;
}
那么为什么第一种代码执行错误，而第二种代码就可以成功执行？仅仅一个const的添加就解决了问题？其实这里是我们在学习C语言时学习过的一个知识的扩展，下面我们通过图解来分析：
上面是常引用的简单讲解，可能我们现在任不知道常引用的好处，下面我们从两个方面来讲解它的好处：
常引用的好处一：
#include<stdio.h>
#include<iostream>
#include<stdlib.h>
using namespace std;
typedef struct Stack
{
int* a;
int top;
int capacity;
}ST;
void StackInit(ST& rs)
{
rs.a = NULL;
rs.top = rs.capacity = 0;
}
void StackPrint(const ST& rs)//在这里我们使用const是为了放置我们在函数中失误将代码写出rs.capacity = 0;这样就可以被检查出来
//①传引用是为了减少传值传参时的拷贝；②可以保护形参传参时不会被改变
{
if (rs.capacity == 0)//既可以接受变量，又可以及接受常量
{
}
}
int main()
{
ST st;
StackInit(st);
StackPrint(st);
return 0;
}
常引用的好处二：
void Func(const int&n)
{
}
int main()
{
int i = 10;
Func(i);
Func(20);
return 0;
}
2.6.3 使用场景
2.6.3.1做返回值
那么我们在分析了上面的代码之后，我们再分析下面的代码：
代码
int Add(int a,int b)
{
int c = a + b;
return c;
}
int main()
{
int ret = Add(1,2);
Add(3,4);
cout<<"Add(1,2)is:"<<ret<<endl;
return 0;
}
图解
对代码进行初步分析：
对代码进一步分析，我们修改部分代码：
那么我们再分析下面的代码：
代码
int& Add(int a,int b)
{
int c = a + b;
return c;
}
int main()
{
int ret = Add(1,2);
Add(3,4);
cout<<"Add(1,2)is:"<<ret<<endl;
return 0;
}
图解：
2.6.3.2做参数
这里关于做参数的实现，其实我们在上面讲解Swap函数时就已经实现，当引用用于做参数时，我们就可以直接对实参进行操作，省去了实参的复制，提升了效率。
#include<iostream>
using namespace std;
void Swap(int&rx, int&ry)
{
int temp = rx;
rx = ry;
ry = temp;
}
int main()
{
int x = 0, y = 1;
Swap(x, y);
return 0;
}
2.6.4引用&传值的效率比较（了解）
以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。
下面的代码只是用来通过时间来进行一个简单的判断，实际意义不大：
#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;
}
2.6.5引用&指针的比较（了解）
这一小结的内容重在我们对引用和指针的理解，并不需要对这一小结的内容死记硬背，所以我们简答了解之后，可以在后续的学习中不断重复理解
1. 引用在定义时必须初始化，指针没有要求
2. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
3. 没有NULL引用，但有NULL指针
4. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)
5. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
6. 有多级指针，但是没有多级引用
7. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
8. 引用比指针使用起来相对更安全
2.7、内联函数
①引言
或许现在的我们还没有太过深入的学习，但我们知道当我们执行程序的时候我们需要对调用的函数进行栈帧的创建，但这个时候我们思考一个问题，若果我们的程序中有一个函数需要多次调用，那么我们在执行程序时，编译器就要多次创建栈帧，在执行之后我们还需要将这个栈帧销毁，这样的话效率太过低下，那么我们有什么办法可以解决这个问题呢？
②概念
以inline修饰的函数叫做内联函数，编译时C++编译器会在内联函数的地方展开，没有函数压栈的开销，内联函数可以提升程序的运行效率
③对引言问题的思考&内联函数的执行
面对引言中的问题我们有什么方法可以解决吗？为了便于讲解，我们这里提供程序的环境，在当前的程序中我们需要多次调用ADD函数，这里ADD函数实现将传入的参数进行相加，然后返回结果；
这里我们提供两种方法：
第一种：C语言中的宏替代
#define ADD(a,b)((a)+(b))
int main()
{
cout<<ADD(1,2)<<endl;
return 0;
}
在这里我们通过宏替代，虽然可以解决我们引用中的问题，但它也带来的许多问题：
1.语法复杂，细节多如牛毛，容易出错；
2.没有类型的安全检查
3.不能进行调试
面对上面宏替代带来的问题，我们这里讲解第二种方法，也就是我们的内联函数：
第二种：内联函数
inline int add(int a, int b)
{
return a + b;
}
int main()
{
int ret = add(1, 2);
return 0;
}
我们虽然说内联函数可以省去函数压栈的开销，但第一次接触C++的我们或者第一次读没有理解这句话是什么意思，现在我通过图解来进行讲解：
④注意
1.inline是一种以空间换时间的做法，省去调用函数的开销，所以这个时候代码很长或者有递归/循环的函数不适宜作为内联函数
2.inline对于编译器只是一种建议，编译器会自动优化，如果定义为inline的函数内有递归/循环等代码，那么编译器在优化时会自动忽略这些定义的内联函数
3.inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到
4.我们对第三点再进行详细讲解
2.8、auto关键字（C++11）
①概念
通过右边的复制，自动推到出变量类型
举例:
#include<iostream>
using namespace std;
int main()
{
int a = 1;
char b = 'a';
auto c = a;
auto d = b;
cout << c << endl;
cout << d << endl;
cout << typeid(c).name() << endl;//这里typeid可以获取传入参数的数据类型，知道即可；
cout << typeid(d).name() << endl;
return 0;
}
执行结果：
这里我们可以得出c和d的数据类型和a和b的数据类型相同，那么我们就可以证明auto可以实现通过右边的复制，自动推到出变量类型。
②用处
1.auto与指针和引用结合起来使用用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&
代码如下：
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.在同一行定义多个变量当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。
代码如下：
void Test()
{
auto a = 1, b = 2;
auto c = 3, d = 4.0; // 该行代码会编译失败，因为c和d的初始化表达式类型不同
}
③注意
1.auto不能作为函数的参数,因为编译器无法事变auto类型参数的实际数据类型，无法推断
void Test(auto a)//这里就是错误的代码，编译器无法对auto数据的数据类型判断
{
……
}
2.auto不能直接用来声明数组，因为我们不知道应该将数组中哪一个元素作为数组的数据类型
void Test()
{
int a[] = {1,2,3};
auto b[] = {4，5，6};//错误
auto c[] = {'A', 123, 12.189};//错误
}
2.9、基于范围的for循环（C++11）
①比较
首先我们回归一下C语言中我们使用for循环的常见：
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 << " ";
cout << endl;
下面是我们基于范围的for循环，处理上面的场景：
//C++11中提供的一种新的访问数组的方式
//自动依次取数组中的值赋值给e（注意这里的e只是个变量，可以换成任何字母）
//自动判断结束
for (auto& e : array)
{
e *= 2;
}
for (auto e : array)
{
cout << e << " ";
}
cout << endl;
下面是我们以后会学习的内容代码，这里我们可以使用我们的范围for循环，在后续的学习中我会再进行分析讲解，这里我们先大概了解一下
map<string,string>dict = { { "string", "字符串" }, { "sort", "排序" },{ "true", "真" } };
//迭代器遍历：
map<string, string>::iterator it = dict.begin();
while (it != dict.end())
{
cout << it->first << ":" << it->second << endl;
it++;
}
cout << endl;
//C++11范围for可以更简单的循环遍历容器
for (auto e : dict)
{
cout << e.first << ":" << e.second << endl;
}
cout << endl;
②讲解
对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。
2.10、指针空值——nullptr（C++11）
①讲解
在良好的C/C++编程习惯中，声明一个变量时最好给该变量一个合适的初始值，否则可能会出现不可预料的错误，比如未初始化的指针。如果一个指针没有合法的指向，我们基本都是按照如下方式对其进行初始化：
void TestPtr()
{
int* p1 = NULL;
int* p2 = 0;
// ……
}
NULL实际是一个宏，在传统的C头文件(stddef.h)中，可以看到如下代码：
#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif
可以看到，NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量。不论采取何种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦，比如：
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;
}
程序本意是想通过f(NULL)调用指针版本的f(int * )函数，但是由于NULL被定义成0，因此与程序的初衷相悖。在C++98中，字面常量0既可以是一个整形数字，也可以是无类型的指针(void * )常量，但是编译器默认情况下将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转(void * )0。
②注意
1. 在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的。
2. 在C++11中，sizeof(nullptr) 与 sizeof((void * )0)所占的字节数相同。
3. 为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。
总结
以上就是我对C++入门内容的讲解与个人的学习思考，这里的auto关键字、基于范围的for循环、指针空值讲解的比较浅显，因为我们部分内容还没学到，所以我们暂时还不能体会到他们的奇妙之处，所以我会在后续的学习中在重新讲解
上述内容如果有错误的地方，还麻烦各位大佬指教【膜拜各位了】【膜拜各位了】
