C++11中的auto关键字

一、引言

        auto其实一直是C++中的一个关键字，它是沿用了C语言中用法，表示变量为自动变量，存放在栈内存上，而在C语言中，声明变量时，写上auto与省略auto关键字表示的语义是一样的，因此，在C语言中声明自动变量，一般省略auto关键字。在C++11前，auto关键字一直沿用了C语言的这个用法。

int main(void){
    int a = 10;    // 常省略auto关键字
    auto int b = 20;   // 等效于 int b = 20;
    
    return 0;
}

二、auto在C++11中的新作用

        正是因为auto经常被省略，显得很鸡肋，所以在C++11中，auto被赋予了新的含义，主要用于自动推断变量的类型。

        基本用法

    auto a = 10;	// 10为int类型，a自动推断为int类型
	auto d = 10.0;	// 10.0为double类型，d自动推断为double类型
	
	auto *p = &a;	// 赋值右侧为int*，auto为int
	auto &r1 = a;	// 赋值右侧为int，auto为int，r1为int&
	auto r2 = r1;	// r2为int类型，因为当赋值右侧为引用时，auto推断会去引用
	
	cout << (&r2) << '\t' << (&r1) << endl; // r2 与 r1的地址不同
	
	// 同时初始化多个值
	auto *p2 = &a, m = 12;
	
	// auto *p2 = &a, m = 12.6;  // 会报错，因为p2推断为int，而m推断为double，两者矛盾
	
	const int n = 15;
	auto c_n = n;		// c_n为int类型，会去掉n的const属性 
	
	cout << (&n) << '\t' << (&c_n) << endl; // n 与 c_n的地址不同

        注意以上代码中 第6行 r2变量和 第16行 c_n变量，赋值符号右侧为引用或const类型时，推断会去掉引用或const修饰。

三、常用场合

        3.1 迭代器
        在处理STL容器（如std::vector、std::list等）时，迭代器是常用的工具。使用auto可以自动推导迭代器的类型，使代码更简洁。

#include <vector>  
#include <iostream>  
  
int main() {  
    std::vector<int> vec = {1, 2, 3, 4, 5};  
  
    // 使用auto推导迭代器类型  
    for (auto it = vec.begin(); it != vec.end(); ++it) {  
        std::cout << *it << " ";  
    }  
  
    return 0;  
}

        3.2 lambda表达式
        在C++11中，lambda表达式提供了一种便捷的方式来定义匿名函数对象。由于lambda表达式的类型通常是编译器自动生成的复杂类型，因此使用auto来捕获这些类型非常有用。

#include <iostream>  
#include <algorithm>  
#include <vector>  
  
int main() {  
    std::vector<int> vec = {1, 2, 3, 4, 5};  
  
    // 使用auto捕获lambda表达式的类型  
    auto print = [](int i) { std::cout << i << " "; };  
  
    std::for_each(vec.begin(), vec.end(), print);  
  
    return 0;  
}

3.3 复杂类型推导
        当涉及到复杂的类型表达式时，如模板实例化或复杂的类型转换，使用auto可以避免冗长的类型声明。

#include <map>  
#include <string>  
#include <iostream>  
  
int main() {  
    std::map<std::string, int> myMap = {{"one", 1}, {"two", 2}, {"three", 3}};  
  
    // 复杂的类型推导  
    auto it = myMap.find("two");  
  
    if (it != myMap.end()) {  
        std::cout << "Found: " << it->first << " => " << it->second << std::endl;  
    }  
  
    return 0;  
}

3.4 与decltype结合使用
        在模板编程中，auto和decltype可以结合起来使用，以提供额外的类型推导能力。这特别适用于需要根据函数参数或模板参数来推导类型的场景。

#include <iostream>  
#include <type_traits>  
  
template<typename T, typename U>  
auto add(T a, U b) -> decltype(a + b) {  
    return a + b;  
}  
  
int main() {  
    auto result = add(1, 2.3); // 自动推导为double类型  
    std::cout << result << std::endl; // 输出3.3  
  
    return 0;  
}

        在上面的例子中，decltype(a + b)用于推导add函数的返回类型，而auto用于自动捕获这个推导出的类型。

        3.5 泛型编程中的局部变量
        在泛型编程中，当函数的局部变量类型依赖于模板参数时，使用auto可以使代码更加简洁。

template<typename T>  
void printType(T value) {  
    auto type_info = typeid(T).name(); // 使用auto来捕获typeid的结果  
    std::cout << "Type of value: " << type_info << std::endl;  
  
    // ... 其他处理  
}  
  
int main() {  
    printType(42);  
    printType(std::string("Hello"));  
    return 0;  
}

        注意：typeid和name()的用法在这里主要是为了示例，实际上typeid(T).name()返回的类型名称可能是编译器特定的，不一定易于理解。在实际应用中，你可能需要更复杂的逻辑来解析或显示类型信息。

四、小结

        在C++11及后续版本中，auto关键字用于自动类型推导，即让编译器自动根据表达式的结果来确定变量的类型。这一特性极大地简化了代码的编写，特别是当变量的类型很复杂或者表达式很长时。

        然而，auto的使用也受到一些限制和考虑事项：

• 初始化需求：

        使用auto声明的变量必须被初始化，因为编译器需要从这个初始化表达式中推导出变量的类型。

• 无法推导为void类型：

        auto不能用于推导void类型的表达式，因为void类型表示“无类型”，它本身不能用作变量类型。

• 复杂的指针和引用：

        虽然auto可以推导出指针和引用的类型，但对于复杂的指针和引用类型（如多层指针、指向数组的指针等），auto的使用可能会让代码可读性变差。在这些情况下，显式指定类型可能是更好的选择。

• 模板函数和泛型编程：

        在模板编程中，auto可以与decltype关键字结合使用，以提供更大的灵活性。但是，对于模板中的具体类型推导，仅仅使用auto可能不足以提供所需的精确度或灵活性。

• 初始化列表和auto：

        auto不能用于推导初始化列表（initializer list）的类型，因为初始化列表并不直接对应一个具体的类型。如果你需要从初始化列表中创建容器，你需要显式指定容器的类型。

• auto与函数声明：

        auto不能用于函数声明中代替返回类型，但在C++14及更高版本中，你可以使用auto在函数声明中的尾置返回类型（trailing return type）来指示函数的返回类型，但这种情况下auto不是用来推导局部变量或函数参数的类型，而是用于指定函数的返回类型依赖于其参数的类型或函数体内的其他逻辑。

• 函数指针和auto：

        虽然auto可以用于推导函数指针的类型，但在处理复杂的函数指针或成员函数指针时，可能会面临可读性或易用性方面的挑战。在这些情况下，明确指定类型可能是更好的选择。

• 局部变量与auto：

        尽管auto为局部变量提供了很大的便利，但在全局范围内或命名空间中使用auto可能会导致类型不明确或代码难以理解。
        总之，auto在C++11及后续版本中是一个非常有用的特性，但它的使用也受到一定的限制和最佳实践的指导。正确使用auto可以显著提高代码的可读性和简洁性，但也需要考虑上述的限制和考虑事项。

附：c++11新增的其他性