C++入门

目录

0.前言：C++的产生

1.命名空间

1.1 为什么要有命名空间

1.2 命名空间定义

1.3 命名空间使用

2.C++的输入输出

3.缺省参数

3.1 缺省参数概念

3.2 缺省参数分类

4.函数重载

4.1 函数重载概念

4.2 C++支持函数重载的原理

5.引用

5.1 引用概念

5.2 使用特性

5.3 使用场景

5.3.1 做参数

1. 输出型参数

2. 大对象传参，用于提高效率

5.3.2 做返回值

传值返回：

传引用返回：

1. 修改返回对象（返回值做左值）

2. 大对象返回提高效率

5.4 常引用

5.5 指针和引用的区别

6.内联函数

6.1 概念

6.2 特性

7.auto关键字（C++11）

7.1 类型别名思考

7.2 auto简介

7.3 auto的使用细则

7.4 auto不能推导的场景

8.基于范围的for循环（C++11）

8.1 范围for的语法

8.2 范围for的使用条件

9.指针空值nullptr（C++11）

9.1 C++98和C语言的指针空值NULL:

9.2 C++11的指针空值nullptr

---

 

0.前言：C++的产生

C语言是结构化和模块化的语言，适合处理较小规模的程序。对于复杂的问题，规模较大的程序时，需要高度的抽象和建模时，C语言则不合适。为了解决软件危机，20世纪80年代，计算机界提出了OOP(object oriented programming:面向对象)思想，支持面向对象的程序设计语言应运而生。1982年，Bjarne Stroustrup博士在C语言的基础上引入并扩充了面向对象的概念，发明了一种新的程序语言。为了表达该语言与C语言的渊源关系，命名为C++。因此:C++是基于C语言而产生的，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计。

除了面向对象思想的引入，C++还针对C语言不足的地方进行了改进，同时引入了许多有用的库，以及编程范式等。

​ 本篇博客主体介绍C++针对C语言的不足所补充的语法知识，以此从C语言过渡到C++，为以后的类和对象学习打下基础。

C++针对C语言的哪些不足之处进行了优化呢？主要为以下几个部分：

• 作用域方面

• IO方面

• 函数方面

• 指针方面

• 宏方面

‍

1.命名空间

1.1 为什么要有命名空间

在C/C++中，变量、函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染,namespace关键字的出现就是针对这种问题的。 ​

1.2 命名空间定义

定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员。

namespace N1
{
    //变量
    int a = 0;
    int b = 1;
​
    //函数
    int Add(int left, int right)
    {
        return left + right;
    }
​
    //类型
    struct Node
    {
        struct Node* next;
        int val;
    };
​
    //嵌套
    namespace N2
    {
        int c = 0;
        int d = 0;
    }
}

注意几点：

• 命名空间的名字一般是开发中的项目名字作为命名空间的名字。

• 命名空间中可以定义变量，函数，类型，包括以后学的类。

• 命名空间可以嵌套。

• 同一个工程允许存在多个相同名字的命名空间，编译器最终会合成在一个命名空间中。

1.3 命名空间使用

针对上面所写的命名空间，我们发现直接使用命名空间的某个成员会报错：未声明的标识符

命名空间的使用有三种方式：

• 加命名空间以及作用域限定符：： ​（指定命名空间）

• 使用using将命名空间中的某个成员引入（展开命名空间）

• 使用using namespace 命名空间名称 将整个命名空间引入（展开命名空间）

int main()
{
    printf("%d\n",N1::a);
​
    return 0;
}
​
using N1::a;
int main()
{
    printf("%d\n",a);
​
    return 0;
}
​
using namespace N1;
int main()
{
    printf("%d\n",a);
​
    return 0;
}

‍

2.C++的输入输出

学习一门语言，怎么能少了hello world呢？

那么C++是如何打印hello world的呢？

#include 
using namespace std;
​
int main()
{
    cout << "hello world << endl";
​
    return 0;
}

短短的几行代码，其实有很多知识点在里面的。

说明：

1. 使用cout标准输出对象(控制台)和cin标准输入对象(键盘)时，必须包含头文件以及按命名空间使用方法使用std。

2. cout和cin是全局的流对象（关于类和对象，后面详细介绍），endl是特殊的C++符号，表示换行输出，他们都包含在包含头文件中。

3. <<和>>并不是C语言中的移位运算符，<<是流插入运算符，>>是流提取运算符。

4. 使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动控制格式。C++的输入输出可以自动识别变量类型（这个就很方便）。

5. 实际上cout和cin分别是ostream和istream类的对象，>>和<<也涉及运算符重载等知识，我们这里只是简单学习他们的使用。

6. 早期标准库将所有功能在全局域中实现，声明在.h后缀的头文件中，使用时只需包含对应头文件即可；后来将其实现在std命名空间下，为了和C头文件区分，也为了正确使用命名空间，规定C++头文件不带.h;旧编译器(vc 6.0)中还支持格式，后续编译器已不支持，因此推荐使用+std的方式。

‍

std命名空间的使用方法：

std是C++标准库的命名空间，这个std如何使用更合理呢？

• 在日常练习中，建议直接using namespace std即可，这样很方便。

• using namespace std展开，标准库就全部暴露出来了，如果我们定义跟库重名的类型/对象/函数，就存在冲突问题。该问题在日常练习中很少出现，但是项目开发中代码较多、规模大，就很容易出现命名冲突问题。所以建议在项目开发中使用，像std::cout这样使用时指定命名空间或者using std::cout展开常用的库对象/类型等方式。

3.缺省参数

3.1 缺省参数概念

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

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

传参时，使用指定的实参。

我们可以认为参数的默认值就是一个备胎。

3.2 缺省参数分类

• 全缺省参数（这个在后面的类和对象经常使用，非常方便）

• 半缺省参数（部分缺省，必须要给实参）

‍

半缺省参数的注意：

半缺省参数的缺省值必须从右往左依次来给出，不能间隔着来给。

就比如void Func（int a = 10, int b, int c）

这种写法会报错

‍

缺省参数的使用注意点：

• 缺省参数不能在声明和定义中同时出现（如果同时出现，恰巧两个位置提供的值不同，编译器无法确认使用哪个缺省值）。我们一般习惯声明中给缺省值，定义中不给缺省值。

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

‍

4.函数重载

4.1 函数重载概念

C++允许在同一个作用域中声明几个功能类似的同名函数，这些函数的形参列表（参数个数或参数类型或类型顺序）不同

函数重载前提：作用域相同，函数名相同。

三个构成重载的条件：

• 参数个数不同

• 参数类型不同

• 参数类型的顺序不同（这也可以认为是类型不同）

#include 
using namespace std;
​
//参数个数不同构成重载
void f1(int a, int b)
{
    cout << "void f1(int a, int b)" << endl;
}
​
void f1(int a)
{
    cout << "void f1(int a)" << endl;
}
​
//参数类型不同构成重载
void f2(int a)
{
    cout << "void f2(int a)" << endl;
}
​
void f2(double a)
{
    cout << "void f2(double a)" << endl;
}
​
//参数类型顺序不同构成重载
void f3(int a, double b)
{
    cout << "void f3(int a, double b)" << endl;
}
​
void f3(double a, int b)
{
    cout << "void f3(double a, int b)" << endl;
}
​
int main()
{
    f1(1, 2);
    f1(1);
    cout << endl;
    f2(1);
    f2(1.0);
    cout << endl;
    f3(1, 1.0);
    f3(1.0, 1);
​
​
    return 0;
}

​

函数重载的两个歧义：

• 参数类型的歧义

void f3(int a, double b)
{
    cout << "void f3(int a, double b)" << endl;
}
​
void f3(double a, int b)
{
    cout << "void f3(double a, int b)" << endl;
}
​
int main()
{
    f3(1, 1);
​
    return 0;
}

这里比编译器会报错，但并不是因为函数参数类型的不匹配，由于隐式类型转换存在的原因，这f3(1, 1)反而都能匹配到这两个函数，造成歧义。

• 函数重载和缺省参数同时存在的歧义

void f2()
{
    cout << "void f2()" << endl;
}
​
void f2(int a = 0)
{
    cout << "void f2(int a = 0)" << endl;
}
​
int main()
{
    f2();
​
    return 0;
}

f2( )同时匹配上面两个函数，造成歧义。

‍

注意：返回值不同不构成重载，因为仅返回值不同而参数相同的话，编译器无法分辨调用哪一个函数。

4.2 C++支持函数重载的原理

知识复习：详见：程序环境和预处理

 

1. 在C/C++中，一个程序要运行起来，需要经历以下几个阶段:预处理、编译、汇编、链接

2. 实际项目通常是由多个头文件和多个源文件构成；当前a.cpp中调用了b.cpp中定义的Add函数时，编译后链接前，a.o的目标文件中没有Add的函数地址，因为Add是在b.cpp中定义的，所以Add的地址在b.o中。那么怎么办呢?

3. 所以链接阶段就是专门处理这种问题，链接器看到a.o调用Add,但是没有Add的地址，就会到b.o的符号表中找Add的地址，然后链接到一起。

那么链接时，面对Add函数，链接接器会使用哪个名字去找呢?这里C和C++编译器都有自己的函数名修饰规则。

我们在Linux环境下分别使用gcc和g++编译器对下面这个函数进行编译并查看汇编代码，发现C语言的函数修饰后名字不变，而C++的函数修饰后变成【_Z+函数长度+函数名+类型首字母】。（注意：不同的C++编译器函数名的修饰规则是不相同的，但只要能保证区分就行） ​​

因此可以得出：C++编译完成后，函数名字的修饰发生改变，编译器将函数参数类型信息添加到修改后的名字。而C语言的函数名字没有添加。所有本质就是：函数名的修饰规则不同。

这里也解释了为什么返回值不同不能构成重载，因为函数名修饰时只添加了参数类型的信息，返回值没有。

‍

5.引用

许多人在初学C语言时，都会感觉指针比较难，C语言的指针在某些应用场景中的确非常复杂，设计C++的大佬们针对指针的复杂性，就设计了一种新语法进行了优化：引用。

---

5.1 引用概念

我们知道，我们每次创建一个变量，就会在内存空间中开辟一块空间。但是引用不同。

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

语法：类型& 引用变量名（对象名） = 引用实体

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

‍

5.2 使用特性

• 引用在定义时必须要初始化

• 一个变量可以有多个引用

• 引用一旦引用一个实体，就不能引用其他实体

其实这里c = b是有一个歧义，他的意思是c是b的别名，还是把b的值赋给c呢？

答案是后者。

5.3 使用场景

5.3.1 做参数

引用做函数参数有两个场景：1.输出型参数（形参的改变也会导致实参的改变）​ 2.大对象传参，用于提高效率

‍

1. 输出型参数

• Swap函数场景

#include 
using namespace std;
​
void Swap1(int& left, int& right)//引用做函数参数
{
    int temp = left;
    left = right;
    right = temp;
}
​
void Swap2(int* left, int* right)
{
    int temp = *left;
    *left = *right;
    *right = temp;
}
​
int main()
{
    int a = 1, b = 2;
    Swap1(a, b);
    cout << a << " " << b << endl;
    int c = 1, d = 2;
    Swap2(&c, &d);
    cout << c << " " << d << endl;
​
    return 0;
}

我们发现，引用用做函数参数和传地址的效果是一样的，都能够交换。

• 单链表场景

typedef int SLTDataType;
​
typedef struct SListNode
{
    SLTDataType data;
    struct SListNode* next;
}SLTNode,*pSLTNode;
​
void SLTPushBack(pSLTNode& pphead, SLTDataType x)
{
    //...
}

上面这个代码和使用二级指针是一个效果，所以：

传指针-->传引用

传二级指针-->传指针的引用

‍

2. 大对象传参，用于提高效率

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;
}

经过测试，我们发现传引用的效率远大于传值。

5.3.2 做返回值

上面引用做参数的两种功能，我们C语言中的指针同样能做到，但是引用做返回值的功能指针并不能完全替代。

在此之前我们解释一下传值返回和传引用返回的区别：

传值返回：

• 传值返回，其实返回的是返回对象的一份拷贝，（这里和传值传参是一个道理）。

• 不管返回对象是在栈上还是在静态区，传值返回都是生成一个返回对象的拷贝作为函数调用的返回值。

• 为什么要传值返回呢？这是因为函数调用结束后，原来的返回对象在栈区中被销毁了。栈帧结束时，系统会清理栈帧置成随机值（看编译器，有时候编译器懒的话就不清理）。

传引用返回：

传引用返回，返回的是返回对象的别名，和原来的返回对象共用一块空间。

了解了传引用返回，再加上上面传值返回的原因，可以很明显的发现，上面的传引用返回有很大的问题。

• 在上面的代码中，我们返回的是返回对象c的别名，和c共用一块空间。

• 但是前面说了，函数调用结束后，原来的返回对象（c）在栈中被销毁了，c的这块空间也被收回，此时再返回c的引用，就会再次访问c这块空间，这是非法的。

• 如果函数返回时，出了函数作用域，返回对象已经还给系统了（函数内局部变量），则必须使用传值返回。如果返回对象还在（函数外局部变量，全局变量，静态变量，堆上的），则可以使用传引用返回。

• 总结：不能返回函数内的局部变量的引用

‍

我们进行代码验证：

int& func()
{
    int a = 1;
    return a;
}
​
int main()
{
    int& num = func();
    cout << num << endl; 
​
    return 0;
}

上述代码中，num变量和a变量共用同一块空间，出了函数作用域a空间回收，那么此时num打印就是非法访问。我们查看结果：

我们发现num值还惊奇的为1，别忘了我们之前说过：栈帧结束时，系统会清理栈帧置成随机值，但有时候并不会，所以说这里num的值完全是不确定的。我们再看一个代码：

int& Add(int a, int b)
{
    int c = a + b;
    return c;
}
​
int main()
{
    int& ret = Add(1, 2);
    cout << "Add(1, 2) is :" << ret << endl;
​
​
    return 0;
}

很显然这里栈帧结束后，回收的栈帧空间被清理了，所以这完全取决于编译器自己，结果是不确定的，再加上这块代码本身就非法访问内存，是错误的。

‍

1. 修改返回对象（返回值做左值）

顺序表中要修改某个元素我们会怎么做？

typedef struct SeqList
{
    SLDataType* a;
    int size;
    int capacity;
}SL;
​
int* SLModify(SL* ps, int pos)
{
    return ps->a + pos;
}
​
int main()
{
    //...
    *(SLModify(&sl, 0)) = 2;//把位置为0的元素修改为2
}

用指针写的话需要解引用，还是对函数的一个返回值解引用，这样代码就变得非常丑陋，但是有了引用之后我们可以这么写：

int& SLModify(SL* ps, int pos)
{
    return ps->a[pos];
}
​
int main()
{
    //...
    SLModify(&sl, 0) = 2;//把位置为0的元素修改为2
}

这样写就非常舒服，符合常理。

‍

2. 大对象返回提高效率

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

5.4 常引用

看一下下面几段代码的区别

//代码一
int a = 10;
int& ra = a;
​
//代码二
const int b = 10;
int& rb = b;
​
//代码三
int c = 10;
const int& rc = c;

这些代码有什么区别呢？ 是否正确呢？

这里我们发现第二个代码有问题，看编译器的报错信息就很容易发现：无法从const int 转化成int&，这里const int转化成int就涉及了权限放大的问题。因为他们都指定同一个变量，所以这个不被允许。

代码一是权限平移，代码三是权限缩小（int转换成const int），这些都是允许的。

‍

下面三段代码就都涉及了权限放大的问题：

const int a = 10;

(const) int& ra = a;

(const) int& b = 10;

double d = 3.14;

(const) int& rd = d;

补充： 代码三的错误并不是因为类型不同，如果没有引用也是对的。

这里其实本质还是涉及了权限放大的问题，类型转换（强制类型转换和隐式类型转换）在底层上会产生一个临时变量，这个临时变量具有常量的属性。类型转换是并不会真的改变原来变量的类型的。

5.5 指针和引用的区别

说明他们两个的区别之前，先说一下引用在底层其实就是用指针（指针常量）实现的。

• 引用的本质是一个指针常量。因此引用初始化后就不能改变。int* const ref=&a;

• 内部一旦发现ref是引用，自动执行指针解引用*ref

‍

指针和引用的不同点：

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

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

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

4. 没有NULL引用，但有NULL指针。

5. 在sizeof中含义不同：引用结果为引用实体的大小，但是指针始终是地址空间所占字节个数（4或8）。

6. 引用自加是引用的实体增加1，指针自加是指针向后偏移一个类型的大小。

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

8. 访问实体的方式不同，指针需要解引用，引用编译器自己处理。

9. 引用比指针使用起来更加安全。

‍

6.内联函数

6.1 概念

我们通过C语言的学习，都知道函数调用都会建立栈帧。

C++引入了一个关键字inline，以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调用建立栈帧的开销，内联函数提升程序运行的效率。所谓展开，也就是函数调用替换为函数体。

我们可以通过汇编代码验证一下：

​

在C语言中也有一种函数在调用时没有栈帧的开销，那就是宏函数。

但是宏函数在使用时是有缺陷的：

宏的缺点：代码可读性差，可维护性差（针对宏函数），复杂；没有类型的安全检查；不方便调试；

宏的优点：代码的可维护性高，增强复用性（针对宏常量）；提高效率，减少栈帧建立（针对宏函数）

inline解决了宏函数的全部缺点，也具备宏函数的优点。

其实在C++中，有很多设计都可以替代宏：const，enum，inline

6.2 特性

1. inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用。缺陷:可能会使目标文件变大；优势:少了调用开销，提高程序运行效率。

2. inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议:将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。

3. inline不可以声明和定义分离，分离会导致链接错误。（因为inline函数被展开，展开了就不需要函数地址，编译阶段inline函数的地址并没有进入符号表中，链接就会找不到。）

补充：在后面类和对象的学习中，我们会学到类中的一个默认的成员函数——默认构造函数，他就是典型的频繁调用并且短小的函数，我们一般直接声明和定义写在一起（在类中定义），此时编译器会把他当做内联函数（不加inline也会当做内联函数）。

‍

7.auto关键字（C++11）

在此之前，先介绍一下C++11

相比于C++98/03，C++11则带来了数量可观的变化，其中包含了约140个新特性，以及对C++03标准中约600个缺陷的修正，这使得C++11更像是从C++98/03中孕育出的一种新语言。相比较而言，C++11能更好地用于系统开发和库开发、语法更加泛华和简单化、更加稳定和安全，不仅功能更强大，而且能提升程序员的开发效率，公司实际项目开发中也用得比较多。

C++11增加的语法特性非常篇幅非常多，比如：列表初始化，变量类型推导，范围for循环，final与override，智能指针，新增加容器---静态数组array，forward_list以及unordered系列，默认成员函数控制，右值引用，lambda表达式，包装器，线程库。

7.1 类型别名思考

在C++中，有些类型名极其变态，比如：

std::mapstd::string,std::string::iterator it=m.begin();

这里的std::mapstd::string,std::string::iterator是一个类型，很显然我们不会写这么长的类型名。

7.2 auto简介

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

注意几点：

• typeid(b).name() 可以得出变量的类型。

• 其实上面场景用auto不合适，一般类型较长时可以用auto自动类型推导。

• auto有两种使用场景：自动推导（类型较长）；范围for循环

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

7.3 auto的使用细则

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

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

• 在同一行定义多个变量

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

7.4 auto不能推导的场景

• auto不能作为函数参数和返回值

• auto不能用来声明数组

‍

8.基于范围的for循环（C++11）

8.1 范围for的语法

C++98中如果要遍历一个数组，可以按照以下方式进行：

#include 
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 << " ";
    }
​
    return 0;
}

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

int main()
{
    int array[] = { 1,2,3,4,5 };
    for (auto& e : array)
    {
        e *= 2;
    }
​
    for (auto e : array)
    {
        cout << e << " ";
    }
​
    return 0;
}

范围for：

自动依次取 array中的数据（不是指针），赋值给e；

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

for (auto* e : array)这种写法是错误的

8.2 范围for的使用条件

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

对于数组而言，就是数组中第一个元素和最后一个元素的范围;

对于类而言，应该提供begin和end的方法，begin和end就是for循环迭代的范围。

• 迭代的对象要实现++和==的操作。(这里涉及迭代器的知识)

‍

9.指针空值nullptr（C++11）

9.1 C++98和C语言的指针空值NULL:

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

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

可以看到，NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)0。 在C++98中，字面常量0既可以是一个整形数字，也可以是无类型的指针(void)常量，但是编译器默认情况下将其看成是一个整形常量，**如果要将其按照指针方式来使用，必须对其进行强转(void)0。**

9.2 C++11的指针空值nullptr

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

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

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

‍