C++ 笔记：类型推导：auto 与 decltype

// auto 推导变量类型
auto x = 42;           // int
auto y = 3.14;        // double
auto z = "hello";     // const char*

// 与引用
int a = 42;
auto& ref = a;        // int&
auto* ptr = &a;       // int*

// 值类型
auto x = value;        // 推导为值类型（去除引用和 const）

// 引用类型
auto& x = value;       // 推导为引用类型

// 指针类型
auto* x = &value;      // 推导为指针类型

// 通用引用（C++14）
auto&& x = value;      // 可能是左值引用或右值引用

// 简化复杂类型
std::map<std::string, std::vector<int>>::iterator it = m.begin();

// 使用 auto 简化
auto it = m.begin();

int x = 42;
decltype(x) y = x;     // y 的类型是 int

const int& ref = x;
decltype(ref) z = x;   // z 的类型是 const int&

int x = 42;
int& ref = x;

decltype(x) a;         // int
decltype(ref) b = x;   // int&
decltype((x)) c = x;   // int&（注意双括号）

template<typename T>
decltype(auto) func(T&& t) {
    return std::forward<T>(t);  // 保留返回类型
}

std::vector<int> vec = {1, 2, 3, 4, 5};

// 传统方式
for (std::vector<int>::iterator it = vec.begin(); it != vec.end(); ++it) {
    std::cout << *it << "\n";
}

// 使用 auto
for (auto it = vec.begin(); it != vec.end(); ++it) {
    std::cout << *it << "\n";
}

// 范围 for（C++11）
for (auto& value : vec) {
    std::cout << value << "\n";
}

auto lambda = [](int x, int y) { return x + y; };
auto result = lambda(1, 2);

auto add(int x, int y) {
    return x + y;  // 返回类型推导为 int
}

std::vector<int> vec = {1, 2, 3};

// 错误：auto 推导为值类型，会拷贝
for (auto value : vec) {
    value = 42;  // 只修改拷贝，不影响原容器
}

// 正确：使用引用
for (auto& value : vec) {
    value = 42;  // 修改原容器
}

// auto 推导为 std::initializer_list
auto x = {1, 2, 3};  // std::initializer_list<int>

// 如果需要 vector
std::vector<int> y = {1, 2, 3};

std::vector<bool> vec = {true, false, true};

// 错误：auto 推导为代理类型
auto value = vec[0];  // std::vector<bool>::reference

// 正确：显式转换
bool value = vec[0];

template<typename T>
void func(T t) {
    // T 的推导规则与 auto 相同
}

func(42);        // T 推导为 int
func(3.14);      // T 推导为 double

template<typename T>
auto forward_value(T&& t) -> decltype(std::forward<T>(t)) {
    return std::forward<T>(t);
}