【C++】 auto关键字：类型推导新利器

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

1.1 类型别名思考

随着程序越来越复杂，程序中用到的类型也越来越复杂，经常体现在：

  1. 类型难于拼写

  2. 含义不明确导致容易出错

#include <string> 
#include <map> 
int main() 
{ 
    std::map<std::string, std::string> m{ { "apple", "苹果" }, { "orange","橙子" },  
    {"pear","梨"} }; 
     
    std::map<std::string, std::string>::iterator it = m.begin();  
    while (it != m.end()) 
     {  
        //.... 
     }  
        return 0; 
}

std::map<std::string， std::string>::iterator 是一个类型，但是该类型太长了，特别容易写错。我们会想到：可以通过 typedef 给类型取别名，比如：

#include <string> 
#include <map> 
typedef std::map<std::string, std::string> Map; 
int main() 
{  
    Map m{ { "apple", "苹果" },{ "orange", "橙子" }, {"pear","梨"} };
    Map::iterator it = m.begin();  
    while (it != m.end()) 
     {      
        //.... 
     }  
    return 0; 
}

使用 typedef 给类型取别名确实可以简化代码，但是 typedef 有会遇到新的难题：

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

typedef char* pstring; 定义了 pstring 是 char*（字符指针）的别名。需要注意的是：typedef 定义的是一个完整的类型别名，而非简单的文本替换。

1. const pstring p1; 这里 const pstring 表示 " 常量的 pstring 类型 "，即" 常量的字符指针 "（char* const），也就是指针本身不可修改。 但 C 语言中，常量指针必须在定义时初始化（否则它将是一个未初始化的常量，没有意义），而此处 p1 未初始化，因此编译会报错（提示 "未初始化的常量"）。

2. const pstring* p2; 这里 const pstring* 表示 " 指向 const pstring 类型的指针 "，即" 指向常量字符指针的指针 "（char* const*）。 这是一个指针变量（不是常量），C 语言允许未初始化的指针变量存在（只是不推荐，可能导致野指针），因此编译可以通过。

总结：

• const pstring 等价于 char* const（常量指针，指针本身不可改），必须初始化。

• const pstring* 等价于 char* const*（指向常量指针的指针），是普通变量，可不用初始化。

注意：typedef 定义的是一个完整类型，const 修饰的是这个完整类型本身，而非被别名替换后的基础类型 。

1.2 auto 简介

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

C++11 中，标准委员会赋予了 auto 全新的含义即：auto 不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto 声明的变量必须由编译器在编译时期推导而得

【注意】

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

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

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

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

1.4 auto 不能推导的场景

1. auto 不能作为函数的参数

// 此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导 
void TestAuto(auto a) 
{}

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

void TestAuto() 
{     
    int a[] = {1,2,3};     
    auto b[] = {4，5，6}; 
}