C++——auto关键字+指针空值nullptr

auto关键字(C++11)

8.1 类型别名思考

随着不断地学习，往后我们的程序会越来越复杂，程序中用到的类型也可能越来越复杂，经常体现在：

1. 类型难于拼写
2. 含义不明确导致容易出错
3. 比如：

这个std::map::iterator就是一个类型，现在我们还看不懂，还没学到。

这个类型就很长，我们写的时候就很容易可能会写错，怎么简化呢？

大家可能会想到用typedef去取一个别名。

这确实是一个方法。

使用typedef给类型取别名确实可以简化代码，但是typedef也存在一些不好的地方。比如：

typedef char* pstring;
int main()
{
    const pstring p1;    // 编译成功还是失败？
    const pstring* p2;   // 编译成功还是失败？
    return 0;
}

大家看定义这两个变量有没有什么问题？

🆗，p1这里有错误，为什么呢？

我们自己分析肯定认为p1是这样的？

const char* p1

那这肯定没什么问题嘛，p1是一个字符指针，const 修饰*p1，那就是p1指向的内容不能被改变罢了。

但是，由于这里typedef char* pstring;的缘故，实际上是这样的：

char* const p1；

即const修饰p1，p1不能被修改，而const修饰的变量是必须初始化的，但这里我们没初始化，所以就报错了。

初始化一下就不报错了。

在编程时，常常需要把表达式的值赋值给变量，这就要求在声明变量的时候清楚地知道表达式的类型。

然而有时候要做到这点并非那么容易，因此C++11给auto赋予了新的含义。

在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，但遗憾的是一直没有人去使用它，大家可以思考下为什么？

8.2 auto简介

C++11中，标准委员会赋予了auto全新的含义即：

auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量在编译阶段编译器会根据初始化表达式来推导auto代表的实际类型。

举一些例子：

定义一个整型变量a，变量b要想接收a，也应该定义成int类型，这没什么问题。

但是，现在我们就可以这样写：

那这时b的类型就不是我们显示指定的，而是根据a自动推导出来的。

当然，其它类型的数据也可以：

我们也可以验证一下b，c，d推断出来的类型对不对：

另外：

使用auto定义变量时必须对其进行初始化

【注意】⚠：

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

8.3 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. 在同一行定义多个变量

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

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

8.4 auto不能推导的场景

1. auto声明的变量不能作为函数的参数
2. 
3. auto不能作为形参类型，因为编译器无法对其实际类型进行推导。
4. auto不能直接用来声明数组
5. 
6. 为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法

1. auto在实际中最常见的优势用法就是跟以后会讲到的C++11提供的新式for循环，还有lambda表达式等进行配合使用

auto在C++11提供的新式for循环的应用我们下面就会讲到。

9. 基于范围的for循环(C++11)

在我们之前学的C语言以及C++11之前如果要遍历一个数组，我们一般都是这样做的：

int main()
{
    int array[] = { 1, 2, 3, 4, 5 };
    for (int* p = array; p < array + sizeof(array) / sizeof(array[0]); ++p)
        cout << *p << " ";
    return 0;
}

于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。

因此C++11中引入了基于范围的for循环。

9.1 范围for的语法

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

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

这样它会自动取数组中的元素赋给e变量，并自动判断结束。

当然这里其实用int就行，但我们刚刚学了auto，用auto的话，如果数组是double或其它类型的元素，我们是不是也可以直接遍历不用改代码啊。

那如果我们现在想改变数组元素的值，可以这样写吗？

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

大家看出来了吗？是不是不行啊！

我们上面说了，它是把数组的元素赋值给了前面的遍历i和e，i和e相当于是数组元素的拷贝，所以我们改变i的值，并不会影响数组元素的值。

如果想改变数组元素，我们可以这样做：

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

看出来区别了吗？

i是数组元素的引用（别名），那改变i是不是就相当于改变数组元素了。

注意⚠：

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

9.2 范围for的使用条件

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

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

比如这种情况就不能用范围for：

void TestFor(int array[])
{
    for(auto& e : array)
        cout<< e <<endl;
}

这里我们能看出来是数组传参，数组传参我们指道其实是传的首元素地址，这里虽然用数组接收，但其本质上还是个指针。

🆗，其它还有与范围for相关的知识我们会在后面的学习中讲到，因为有些知识我们现在还没办法很好的理解。

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

在良好的C/C++编程习惯中，声明一个变量时最好给该变量一个合适的初始值，否则可能会出现不可预料的错误，比如未初始化的指针。

如果一个指针没有合法的指向，我们基本都是按照如下方式对其进行初始化：

int* p1 = NULL;

NULL就是空指针嘛，我们学过C语言知道其实NULL就是把0强制类型转换为void*的指针了，实际是一个宏。

那我们来看这样一个代码：

void f(int)
{
    cout << "f(int)" << endl;
}
void f(int*)
{
    cout << "f(int*)" << endl;
}
int main()
{
    f(0);
    f(NULL);
    return 0;
}

这两次函数调用会如何匹配？

欸，NULL不是指针嘛，为什么f(NULL);调用的也是第一个函数呢？
原因在于NULL在C++ 中的定义发生了一些改变。

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

意思呢就是在C++中NULL其实就是0。

所以要想NULL调用第二个函数：

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

那由于以上这些原因呢，C++11引入了一个新关键字nullptr来表示空指针：

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

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

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