1.基本规则

• auto 会根据初始化表达式的类型推导出变量的类型。
• 如果初始化的是值类型，auto 推导出的也是值类型。
• 如果初始化的是引用类型，auto 会忽略引用类型，并推导出被引用对象的类型。
• 如果初始化表达式是常量 (const)，且 auto 不是引用类型，推导出的类型会去掉 const 限定符。volatile同理。

常见例子：

int x = 0;
const auto& r1 = x; // r1 是对 x 的常量引用，类型是 const int&
auto r2 = r1;       // r2 是什么类型？

推导过程：

1. r1 是一个对 x 的常量引用（const int&），它引用了一个 int 类型的对象 x。
2. 当 auto 作用于 r2 时，类型推导的规则是，auto 会忽略引用类型，而只根据被引用的对象的类型来推导。

因此：

• r1 的类型是 const int&，但 r2 并不是引用，而是值类型。
• 由于 r1 引用了一个 const int 类型，auto 会推导出 r2 的类型为 int，而不是 const int&。

结论：

r2 的类型是 int，它是对 r1 所引用值的拷贝，而不再是引用。

//数组
int arr[] = {1, 2, 3};
auto x = arr;  // x 的类型是 int*，数组退化为指针

//指针
int x = 42;
int* ptr = &x;
auto y = ptr;  // y 的类型是 int*

//Lambda
auto lambda = [](int x) { return x + 1; };//在 Lambda 表达式中，auto 常用于类型不明确的变量推导。

//使用引用符号   保留const与初始化表达式的引用特性
const int x = 42;
auto y = x;  // y 是 int, const 被去掉
auto& z = x;  // z 是 const int&, 保留 const 限定符

2.auto 与 decltype

C++14 引入了 decltype(auto)，可以保留表达式（expression）的所有类型信息（包括引用和 const 限定符）

//auto 与decltype的结合
int x = 42;
const int& ref = x;
decltype(auto) y = ref; // y 的类型与 ref 保持一致，即 const int&

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

decltype的几个特殊例子：

//expression是函数，则返回值为函数返回值的类型；
float* func(){};
decltype(func) b4;                      //b4是float*类型


//expression是是带括号的变量，则返回值为引用类型；
int i= 0;
decltype(i) d1;                         //d1是int类型
decltype((i)) d2;                       //错误！ d2是int&类
型，必须初始化
decltype((i)) d3 = d1;                  //正确！ d3是int&类型

//数组
int a[] = {1,2,3};
auto a1(a);                //a1是int*，指向a[0]
decltype(a) a3 = {0,1,2}；    // decltype(a)返回类型是含有三个整形元素的数组，只能是三个，decltype(a) a3 = {0,1,2,3}；会报错

//解引用 返回引用
int i= 5, *p = &i, &r = i;
decltype(r + 0) b1;                     //b1是整型，表达式结果是整型
decltype(*p) b2;                        //错误！ 解引用操作，得到的是int&类型，未初始化
decltype(&p) b3;                        //取址操作，b3是int**类型