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) { // 函數(shù)返回類型也可以用 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 為數(shù)組，所以不能使用 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 規(guī)則)
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 循環(huán)中的應用
    std::cout << "Vector elements: ";
    for (auto num : vec) { // num 的類型被推導為 int (vec 的元素類型)
        std::cout << num << " ";
    }
    std::cout << std::endl;
    // 示例 4: decltype 用于函數(shù)返回類型（后置返回類型）
    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;
}