C++11：自动类型推导 auto 和 decltype（上）

在 C++11标准中，引入了两个非常有用的关键字：auto 和 decltype。这两个关键字在提高编码效率、代码可读性以及维护性方面起到了巨大作用。今天，我们将深入探讨 auto的用法，并通过实际的代码示例来说明怎么使用它。

auto 的用法

关键字 auto 允许编译器自动推导变量的类型，从而使程序员不必显式地指定它们。这一特性在处理复杂类型或模板编程时尤为有用，能够使代码更加简洁明了。

1、基本用法

在最基本的用法中，auto 可以用于变量声明，让编译器自动推导变量的类型。

auto x = 5; // x 被推导为int
auto y = 3.14; // y 被推导为double
auto p = &x; // &x 的结果是 int* 指针，所以推导出 p 的类型是 int*
auto url = "https://kangxishuo.com"; // 双引号包围起来的字符串是 const char*，所以推导出 url 的类型是 const char*

2、用于迭代器

在容器操作中，auto 可以简化迭代器的声明，这也是 auto 的典型应用场景。

std::vector<int> vec = {1, 2, 3, 4, 5};
for(auto it = vec.begin(); it != vec.end(); ++it) {
    std::cout << *it << " ";
}

3、用于函数返回类型

C++14 进一步扩展了 auto 的用法，允许用它来指定函数的返回类型。

auto add(int x, int y) -> int {
    return x + y;
}

4、用于范围for循环

auto 可以在范围 for 循环中用来自动推导元素类型。

std::vector<int> vec = {1, 2, 3, 4, 5};
for(auto elem : vec) {
    std::cout << elem << " ";
}

5、用于泛型编程

泛型编程中，当我们不知道变量的类型，或者不希望指明具体类型的时候，可以使用 auto。

#include <iostream>
using namespace std;

class A{
public:
    static int get(void){
        return 100;
    }
};

class B{
public:
    static const char* get(void){
        return "https://kangxishuo.com/";
    }
};

template <typename T>
void func(void){
    auto val = T::get();
    cout << val << endl;
}

int main(void){
    func<A>();
    func<B>();
    return 0;
}

// 运行结果
// 100
// https://kangxishuo.com/

本例中的模板函数 func() 会调用类的静态函数 get()，并对它的返回值做统一处理，但是 get() 的返回值类型并不一样，而且不能自动转换。这种要求在以前的 C++ 版本中实现起来非常麻烦，需要额外增加一个模板参数，并在调用时手动给该模板参数赋值，用以指明变量 val 的类型。

但是有了 auto 类型自动推导，编译器就根据 get() 的返回值自己推导出 val 变量的类型，就不必再增加一个模板参数。

6、结合 decltype使用

有时候，我们希望定义一个变量，其类型与某个表达式的类型完全相同，这时就可以结合 decltype 和 auto 使用。

decltype(auto) var = x; // 若x的类型是int，则var的类型也为int

7、auto 与 const 结合

auto 与 const 结合的用法：

• 当类型不为引用时，auto 的推导结果将不保留表达式的 const 属性；
• 当类型为引用时，auto 的推导结果将保留表达式的 const 属性。

我们通过实例理解一下：

int x = 0;
const auto n = x;  //n 为 const int ，auto 被推导为 int
auto f = n; //f 为 const int，auto 被推导为 int（const 属性被抛弃）
const auto &r1 = x; //r1 为 const int& 类型，auto 被推导为 int
auto &r2 = r1; //r1 为 const int& 类型，auto 被推导为 const int 类型`在这里插入代码片`

auto 的限制

1、使用 auto 的时候必须对变量进行初始化，否则无法推断变量类型。

2、auto 不能在函数的参数中使用。

3、auto 不能作用于类的非静态成员变量（即没有 static 修饰的成员变量）。

4、auto 关键字不能定义数组，例如，下面的例子是错误的：

char url[] = “https://kangxishuo.com/”;
auto str[] = url; //str 为数组，所以不能使用 auto

5、auto 不能作用于模板参数，看下面的例子：

template <typename T>
class A{
    //……
};
int  main(){
    A<int> C1;
    A<auto> C2 = C1;  //错误
    return 0;
}

代码示例

我们再通过一个实际的例子来展示 auto 的使用。假设我们有一个函数，返回一个复杂的容器类型，我们可以使用 auto 来简化变量的声明。

#include <iostream>
#include <map>
#include <vector>

std::map<std::string, std::vector<int>> complexFunction() {
    // 假设这个函数做了很多复杂的操作
    return {{"key", {1, 2, 3, 4, 5}}};
}

int main() {
    auto result = complexFunction(); // 自动推导为std::map<std::string, std::vector<int>>
    for(auto& pair : result) {
        std::cout << pair.first << ": ";
        for(auto& elem : pair.second) {
            std::cout << elem << " ";
        }
        std::cout << std::endl;
    }
}
// 输出：key: 1 2 3 4 5 

关键字 auto 是 C++11 标准引入的一个强大特性，通过使用 auto，我们不仅能够使代码更加简洁，还可以减少因类型错误而引起的编译错误。这在处理复杂类型时尤其有用，可以大大提高编码效率和可读性。