auto 和 decltype 的区别
auto 和 decltype 区别
在 C++11 中,auto 和 decltype 都用于类型推导,但它们的推导方式和使用场景不同。
核心区别:
auto:根据变量的初始化表达式推导类型,默认会忽略顶层const和引用。decltype:根据表达式本身推导类型,不实际执行表达式,能够保留const和引用属性。
一、auto 的用法
auto 让编译器根据初始化值自动推导变量类型。
int a = 10;
auto b = a; // int
const int c = 20;
auto d = c; // int,忽略顶层 const
int& ref = a;
auto e = ref; // int,忽略引用
auto& f = ref; // int&,显式保留引用
auto 的推导规则
1. 默认忽略顶层 const 和引用
const int x = 10;
const int& y = x;
auto a = x; // int
auto b = y; // int
const auto c = x; // const int
auto& d = y; // const int&
2. 保留底层 const
const int x = 10;
const int* p = &x;
auto q = p; // const int*
这里 q 仍然是指向 const int 的指针。
3. auto&& 使用转发引用推导规则
int x = 10;
auto&& a = x; // int&
auto&& b = 10; // int&&
auto&& 在这种推导场景下可以绑定左值和右值,并通过引用折叠得到最终类型。
二、decltype 的用法
decltype 用于获取一个表达式的类型,并且不执行表达式。
int a = 10;
decltype(a) b = 20; // int
const int c = 30;
decltype(c) d = 40; // const int
int& ref = a;
decltype(ref) e = a; // int&
与 auto 不同,decltype 可以保留变量声明中的 const 和引用。
decltype 的特殊规则
decltype 的结果取决于表达式的写法和值类别。
1. 如果表达式是未加括号的变量名,直接返回声明类型
int a = 10;
decltype(a) b = 20; // int
2. 如果表达式不是未加括号的变量名,则根据值类别推导
| 表达式值类别 | decltype 推导结果 |
|---|---|
| 左值(lvalue) | T& |
| 将亡值(xvalue) | T&& |
| 纯右值(prvalue) | T |
例如:
int a = 10;
decltype(a) b = 20; // int
decltype((a)) c = a; // int&
decltype(a + 1) d = 30; // int
注意:
decltype(a) // int
decltype((a)) // int&
仅仅多了一层括号,推导结果就可能不同。
原因是:
a:未加括号的变量名,直接使用声明类型。(a):普通表达式,其值类别是左值,所以推导为int&。
这是 decltype 最常见的面试考点。
三、auto 和 decltype 对比
int x = 10;
const int& r = x;
auto a = r; // int
decltype(r) b = x; // const int&
| 对比项 | auto | decltype |
|---|---|---|
| 引入版本 | C++11 | C++11 |
| 推导依据 | 初始化表达式 | 指定表达式 |
| 是否需要初始化表达式 | 通常需要 | 不需要 |
| 是否保留引用 | 默认不保留 | 保留或按值类别推导 |
| 是否保留顶层 const | 默认不保留 | 保留 |
| 是否执行表达式 | 初始化时会求值 | 不会求值 |
| 典型用途 | 简化变量声明 | 精确获取表达式类型 |
例如:
int x = 10;
auto a = x; // int
decltype(x) b = 20; // int
decltype((x)) c = x; // int&
四、decltype(auto):C++14
C++14 引入 decltype(auto),它结合了两者的写法特点:
- 像
auto一样通过初始化表达式推导类型。 - 使用
decltype的规则进行类型推导,能够保留引用和const。
int x = 10;
auto a = (x); // int
decltype(auto) b = (x); // int&
decltype(auto) c = x; // int
在函数返回值中尤其重要
int x = 10;
int& getValue() {
return x;
}
使用 auto:
auto func1() {
return getValue();
}
推导结果是 int,返回的是值。
使用 decltype(auto):
decltype(auto) func2() {
return getValue();
}
推导结果是 int&,返回的是引用。
因此:
func1() = 20; // 编译错误,返回临时值
func2() = 20; // 正确,修改 x
需要注意,返回局部变量引用仍然是不安全的:
decltype(auto) func() {
int x = 10;
return (x); // 推导为 int&,产生悬空引用
}
五、实际应用:泛型编程
假设需要实现一个泛型函数:
template<typename T, typename U>
auto add(T a, U b) {
return a + b;
}
C++14 开始,编译器可以根据 return 表达式推导返回类型。
如果在 C++11 中,可以使用尾置返回类型:
template<typename T, typename U>
auto add(T a, U b) -> decltype(a + b) {
return a + b;
}
这里的 decltype(a + b) 会推导加法表达式的返回类型。
例如:
add(1, 2); // int
add(1, 2.5); // double
如果需要精确保留返回值的引用属性,也可以在 C++14 中使用:
template<typename Container>
decltype(auto) getFirst(Container& c) {
return c[0];
}
对于 std::vector<int>,c[0] 返回 int&,因此 getFirst 也返回 int&。
六、举个例子
看下面的代码,判断每个变量的类型:
int x = 10;
const int cx = x;
const int& rx = x;
auto a = cx;
auto b = rx;
auto& c = rx;
decltype(cx) d = 10;
decltype(rx) e = x;
decltype(x) f = 20;
decltype((x)) g = x;
decltype(auto) h = x;
decltype(auto) i = (x);
答案如下:
| 变量 | 类型 | 原因 |
|---|---|---|
| a | int | auto 忽略顶层 const |
| b | int | auto 忽略引用和顶层 const |
| c | const int& | auto& 保留引用和底层 const |
| d | const int | decltype 保留声明类型 |
| e | const int& | 直接保留 rx 的声明类型 |
| f | int | 未加括号的变量名 |
| g | int& | (x) 是左值表达式 |
| h | int | decltype(auto) 按 decltype(x) 推导 |
| i | int& | decltype(auto) 按 decltype((x)) 推导 |
七、总结
可以用三句话回答:
auto根据初始化表达式推导变量类型,默认忽略引用和顶层const,主要用于简化变量声明。decltype获取表达式的类型,不会实际执行表达式,可以保留const、引用,并且会根据表达式的值类别推导。decltype(auto)是 C++14 引入的特性,可以像auto一样自动推导,但遵循decltype的规则,常用于需要保留引用语义的函数返回值。
最重要的机制:
int x = 10;
auto a = (x); // int
decltype(x) b = 10; // int
decltype((x)) c = x; // int&
decltype(auto) d = (x); // int&
理解这四行代码的区别,基本就掌握了 auto 和 decltype 的核心机制。

浙公网安备 33010602011771号