类型推导 auto 与 decltype

template<typename T>
void f(T param);          // 传值 → 忽略引用和顶层 const

template<typename T>
void f(T& param);         // 传引用 → 保留 cv 限定符

auto x = expr;            // 传值推导：忽略引用、顶层 const
auto& y = expr;           // 引用推导：保留 cv 限定符
const auto& z = expr;     // 引用 + const 推导
auto&& w = expr;          // 转发引用（万能引用）

auto x;              // 错误：没有初始化表达式
auto arr[10];        // 错误：不能声明数组
class Foo {
    auto member = 0;  // 错误：非静态成员不能用 auto（C++11，C++14 前）
};
void f(auto param);  // 错误（C++20 前不是合法语法）

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

int main() {
    // 学生选课数据：课程名 → 学生名单
    std::map<std::string, std::vector<std::string>> course_enrollment = {
        {"数据结构", {"张三", "李四", "王五"}},
        {"操作系统", {"赵六", "张三"}},
        {"编译原理", {"李四", "钱七", "孙八", "王五"}}
    };

    std::cout << "===== 选课情况 =====" << std::endl;

    // 不使用 auto：类型名超长
    for (std::map<std::string, std::vector<std::string>>::const_iterator
             it = course_enrollment.begin();
         it != course_enrollment.end(); ++it) {
        std::cout << it->first << " (" << it->second.size() << " 人): ";
        for (std::vector<std::string>::const_iterator
                 sit = it->second.begin();
             sit != it->second.end(); ++sit) {
            std::cout << *sit << " ";
        }
        std::cout << std::endl;
    }

    // 使用 auto：简洁清晰
    std::cout << "\n--- 使用 auto 重写 ---" << std::endl;
    for (const auto& pair : course_enrollment) {
        std::cout << pair.first << " (" << pair.second.size() << " 人): ";
        for (const auto& name : pair.second) {
            std::cout << name << " ";
        }
        std::cout << std::endl;
    }

    // auto 结合算法
    auto it = course_enrollment.find("数据结构");
    if (it != course_enrollment.end()) {
        std::cout << "\n找到课程: " << it->first << std::endl;
    }

    return 0;
}

#include <iostream>
#include <type_traits>
#include <string>

// C++11 写法：后置返回类型 + decltype
template <typename T, typename U>
auto add_v1(const T& a, const U& b) -> decltype(a + b) {
    return a + b;
}

// C++14 写法：auto 返回类型推导（无需后置）
template <typename T, typename U>
auto add_v2(const T& a, const U& b) {
    return a + b;
}

// decltype 与 auto 的区别演示
int main() {
    // ---- 基本使用 ----
    auto result1 = add_v1(3, 4.5);
    std::cout << "3 + 4.5 = " << result1
              << " (类型: " << typeid(result1).name() << ")" << std::endl;

    auto result2 = add_v1(100L, 200);  // long + int → long
    std::cout << "100L + 200 = " << result2
              << " (类型: " << typeid(result2).name() << ")" << std::endl;

    // ---- decltype vs auto 的引用差异 ----
    int x = 42;
    int& ref_x = x;

    auto        a = ref_x;     // a 是 int（忽略引用）
    decltype(ref_x) b = ref_x; // b 是 int&（保留引用）

    a = 100;
    std::cout << "\nauto 推导:   a=" << a << ", x=" << x
              << " ← x 不变，a 是独立变量" << std::endl;

    b = 200;
    std::cout << "decltype 推导: b 是引用，b=200, x=" << x
              << " ← x 被修改" << std::endl;

    // ---- decltype((x)) 双括号陷阱 ----
    decltype(x)  c = x;   // c 是 int
    decltype((x)) d = x;  // d 是 int&（双括号使 x 成为左值表达式）

    static_assert(std::is_same<decltype(x), int>::value,
                  "decltype(x) 应该是 int");
    static_assert(std::is_same<decltype((x)), int&>::value,
                  "decltype((x)) 应该是 int&（双括号陷阱）");

    std::cout << "\n双括号陷阱: decltype(x) 是 int, "
              << "decltype((x)) 是 int&" << std::endl;

    return 0;
}

#include <iostream>

int main() {
    const int ci = 10;
    const int& cri = ci;

    auto a1 = ci;       // int（忽略顶层 const）
    auto a2 = cri;      // int（cri 是引用，按值推导忽略 const）
    auto& a3 = ci;      // const int&（引用推导保留 const）
    const auto& a4 = ci;// const int&

    a1 = 99;  // 正确，a1 不是 const
    // a3 = 99;  // 错误，a3 是 const int&

    std::cout << "ci=" << ci << ", a1=" << a1 << std::endl;

    // 想要保留顶层 const，必须显式写出
    const auto a5 = ci;   // const int

    return 0;
}