C++中的auto关键字

从 C++11 标准开始引入，它主要用于自动类型推导，让编译器根据变量的初始化表达式自动推断变量的类型，从而简化代码编写，提高代码的可读性和可维护性。

在定义变量时，使用 auto 关键字代替具体的类型，编译器会根据初始化表达式自动推断变量的类型。

#include <iostream>

int main() {
    auto num = 10;  // 编译器自动推断 num 的类型为 int
    auto str = "Hello";  // 编译器自动推断 str 的类型为 const char*
    std::cout << "num: " << num << ", str: " << str << std::endl;
    return 0;
}

1. 迭代器类型推导

在使用容器的迭代器时，迭代器的类型可能比较复杂，使用 auto 可以避免手动书写冗长的类型名。

#include <iostream>
#include <vector>

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

2. 模板编程

在模板编程中，由于模板参数的存在，某些类型可能很难手动确定，auto 可以让编译器自动处理类型推导。

#include <iostream>
#include <functional>

template<typename T, typename U>
auto add(T a, U b) -> decltype(a + b) {
    return a + b;
}

int main() {
    auto result = add(3, 2.5);  // 自动推导 result 的类型为 double
    std::cout << "Result: " << result << std::endl;
    return 0;
}

3. Lambda 表达式

Lambda 表达式的类型是编译器生成的匿名类型，无法手动书写，使用 auto 可以方便地存储和使用 Lambda 表达式。

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    // 使用 auto 存储 Lambda 表达式
    auto square = [](int x) { return x * x; };
    for (auto& num : vec) {
        num = square(num);
        std::cout << num << " ";
    }
    std::cout << std::endl;
    return 0;
}

1. 初始化要求

使用 auto 定义变量时必须进行初始化，因为编译器需要根据初始化表达式来推断变量的类型。

// 错误：没有初始化，无法推断类型
// auto x; 

// 正确：根据初始化表达式推断类型为 int
auto x = 10; 

2. 类型会忽略顶层 const 和引用

auto 在推导类型时会忽略变量的顶层 const 和引用属性，但会保留底层 const。

const int a = 10;
auto b = a;  // b 的类型为 int，顶层 const 被忽略

int c = 20;
int& ref = c;
auto d = ref;  // d 的类型为 int，引用被忽略

const int* ptr = &a;
auto e = ptr;  // e 的类型为 const int*，底层 const 被保留