C++ auto和decltype的用法和区别全解析

auto x = 42;       // x 的类型被推导为 int
auto y = 3.14;     // y 的类型被推导为 double
auto str = "hello"; // str 的类型被推导为 const char*

std::vector<std::map<std::string, int>> complexVector;
// 不用写复杂的迭代器类型
for (auto it = complexVector.begin(); it != complexVector.end(); ++it) {
    // ...
}

template <typename T, typename U>
auto add(T t, U u) -> decltype(t + u) { // 函数返回类型也可以用 auto + 尾置返回类型 (C++11)
    return t + u;
}

int i = 10;
const int ci = 20;
int& ref_i = i;
const int& cref_i = ci;
auto a = ci;    // a 是 int (顶层 const 被忽略)
auto b = ref_i; // b 是 int (引用被忽略)
auto c = cref_i; // c 是 int (引用和顶层 const 被忽略)
a = 30; // 合法
b = 40; // 合法
// 如果需要保留引用或 const，需要显式加上
auto& d = ref_i; // d 是 int&
const auto e = ci; // e 是 const int

int arr[5] = {1, 2, 3, 4, 5};
auto p = arr; // p 的类型是 int*
void func();
auto pf = func; // pf 的类型是 void (*)()

int  x = 0;
auto *p1 = &x;   //p1 为 int *，auto 推导为 int
auto  p2 = &x;   //p2 为 int*，auto 推导为 int*
auto &r1  = x;   //r1 为 int&，auto 推导为 int
auto r2 = r1;    //r2 为  int，auto 推导为 int

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 类型`在这里插入代码片`

char url[] = “http://c.biancheng.net/”;
auto str[] = url; //arr 为数组，所以不能使用 auto

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

int i = 42;
decltype(i) di; // di 的类型是 int
double d = 3.14;
decltype(d) dd = d; // dd 的类型是 double

int i = 0;
int& ref_i = i;
const int ci = 1;
const int& cref_i = ci;
decltype(ref_i) dr = i;   // dr 是 int&
decltype(ci) dc = 2;      // dc 是 const int
decltype(cref_i) dcr = ci; // dcr 是 const int&

int i = 0;
decltype((i)) di = i; // di 是 int&
decltype((5)) d5 = 5; // d5 是 int&& (5 是右值)

int i = 0;
int* p = &i;
decltype(*p) d = i; // *p 是左值表达式，d 是 int&
decltype(i + 1) di = i; // i+1 是右值表达式，di 是 int
decltype(++i) di_inc = i; // ++i 是左值表达式 (返回 i 的引用)，di_inc 是 int&
decltype(i++) di_post; // i++ 是右值表达式 (返回旧值的副本)，di_post 是 int

template <typename T, typename U>
auto add(T t, U u) -> decltype(t + u) { // 推导返回类型
    return t + u;
}

auto lambda = []{ return 42; };
decltype(lambda) anotherLambda = lambda; // anotherLambda 是同类型 Lambda

int i = 0;
int& ref_i = i;
const int ci = 1;
const int& cref_i = ci;
auto a = ref_i;        // a 是 int
decltype(auto) da = ref_i; // da 是 int& (应用 decltype 规则)
auto b = cref_i;       // b 是 int
decltype(auto) db = cref_i; // db 是 const int&
auto c = 5;            // c 是 int
decltype(auto) dc = 5; // dc 是 int (5 是右值)

#include <iostream>
#include <vector>
#include <typeinfo> // 用于打印类型信息（仅作演示，非必需）
int main() {
    // 示例 1: 使用 auto 推导变量类型
    auto x = 42; // 编译器推导 x 为 int 类型
    auto y = 3.14; // 编译器推导 y 为 double 类型
    auto vec = std::vector<int>{1, 2, 3}; // 编译器推导 vec 为 std::vector<int> 类型
    // 示例 2: 使用 decltype 获取表达式的类型
    decltype(x) a = x; // a 的类型与 x 相同 (int)
    decltype(3.14 + 1) b; // b 的类型是 3.14(double) + 1(int) 的结果类型 (double)
    decltype(vec[0]) element = vec[0]; // element 的类型是 vector 元素类型 (int&)
    // 示例 3: auto 在范围 for 循环中的应用
    std::cout << "Vector elements: ";
    for (auto num : vec) { // num 的类型被推导为 int (vec 的元素类型)
        std::cout << num << " ";
    }
    std::cout << std::endl;
    // 示例 4: decltype 用于函数返回类型（后置返回类型）
    auto add = [](int a, int b) -> decltype(a + b) {
        return a + b;
    };
    auto sum = add(x, 10); // sum 的类型是 decltype(a + b)，即 int
    // (可选) 打印一些变量的类型信息 (需要 typeid)
    std::cout << "Type of x: " << typeid(x).name() << std::endl;
    std::cout << "Type of y: " << typeid(y).name() << std::endl;
    std::cout << "Type of a: " << typeid(a).name() << std::endl;
    std::cout << "Type of b: " << typeid(b).name() << std::endl;
    std::cout << "Type of element: " << typeid(element).name() << std::endl;
    std::cout << "Type of sum: " << typeid(sum).name() << std::endl;
    return 0;
}