auto 关键字

面试官： C++11 引入了 auto 关键字，它极大地改变了我们编写 C++ 代码的方式。

你能简单解释一下，auto 关键字的作用是什么吗？使用它有什么好处？

回答：

  • auto 关键字的作用是，省略具体的变量类型，而是根据实际变量的类型推导出其类型。
  • 使用 auto 关键字，就不必写复杂的类型名（比如常用的 STL 迭代器），让代码看上去更简洁。
  • 同时，auto 关键字还能实现类似“多态”的效果（这里说“多态”不太准确，应该说，是泛型编程），使得同一份代码可以被许多不同的类型复用。

面试官 (补充与澄清): 你说的很对。我们来把你的回答再精确化和补充一下。

auto 的作用： 它是一个类型占位符。编译器会在编译时，根据变量的初始化表达式，自动推导出变量应该具有的正确类型。

auto 的好处：

  1. 简洁性 (Brevity)：正如你所说，它可以避免写冗长、复杂的类型名。这一点在处理 STL 的迭代器和模板时尤其明显。

    1
2
3
4
5

    // C++03
std::vector<std::string>::iterator it = my_vec.begin();

// C++11 with auto
auto it = my_vec.begin(); // 简洁、易读、不易出错

  2. 正确性 (Correctness)：auto 保证了变量的类型与初始化表达式的类型完全匹配，避免了因手写类型错误或发生意外的类型转换而导致的 bug。

  3. 可维护性 (Maintainability)：如果初始化表达式的类型未来发生了变化（比如一个函数的返回值从 int 变成了 long long），使用了 auto 的代码不需要任何修改，会自动适应新的类型。

关于你提到的“多态效果”： 这个描述非常有趣！auto 本身是在编译期进行类型推导，不直接产生运行时的多态（那需要虚函数）。但你说的“使得同一份代码可以被许多不同的类型复用”，这个思想非常接近泛型编程 (Generic Programming)。 auto 在 C++14 的泛型 Lambda 中 [](auto x){ ... } 和 C++20 的函数参数中 void func(auto param)，确实扮演了类似模板参数的角色，让一段代码能适用于多种类型。你的直觉是非常准的。

auto 对顶层 const 和 & 的忽略

面试官 (深入提问): 好的，你对 auto 的基本用法很了解。但 auto 在类型推导时，有一个特性需要特别注意：它通常会忽略顶层的 const 和引用 &。

请看下面这段代码：

1
2
3
4
5

const int x = 10;
const int& rx = x;

auto a = x;  // a 的类型是什么？
auto b = rx; // b 的类型是什么？

你觉得，变量 a 和 b 被推导出的类型分别是什么？它们是 int 还是 const int 还是 const int&？

顶层 const 和底层 const

  • 顶层 const：修饰变量本身，auto 会去掉（除非你显式加 const）。
  • 底层 const：修饰指针/引用所指的对象，auto 会保留。

回答：

  • x 和 rx 中的 const 都是顶层 const。
  • 由于 auto 会忽略顶层的 const 和 &，因此，a 和 b 被推导出的类型都是 int。

可以这样理解：

  • 顶层 const：只是说“这个变量自己不能改”，但如果你复制一份（值拷贝），那份拷贝当然可以改，所以 auto 会去掉它。
  • 底层 const：是说“这个指针/引用指向的东西不能改”，这个限制是语义上重要的，auto 必须保留。

面试官 (解释与确认): 你说得完全正确。

auto 类型推导规则：

  1. 当类型不是指针或引用时，推导结果会抛弃表达式的顶层 const 属性和引用属性。
  2. 当类型是指针或引用时，推导结果会保留表达式的底层 const 属性。

对于你的例子：

  • const int x = 10;

    • auto a = x; -> a 的类型是 int (抛弃了 const)

  • const int& rx = x;

    • auto b = rx; -> b 的类型是 int (抛弃了 const 和 &)

为什么 auto 要这么设计？ 这和 C++ 的设计哲学有关。auto 的设计目标是 “类型推导应该让程序员更方便地使用表达式的值，而不是完美地复刻表达式的类型”。

换句话说，auto 默认会去除那些不影响使用的“装饰性”属性，让我们更专注于值本身。

面试官 (继续追问): 好的，那如果我希望 auto 推导出的类型，保留表达式的顶层 const 属性或引用属性，我应该怎么做？

例如，我希望 b 的类型是 const int&，而不是 int，我应该怎么修改代码？

回答：

  • 只需要在 auto 表达式中把我们需要的部分写出来就行。
  • 例如，我们需要 const 和 &，那么只需要这样定义：const auto& b = rx;

面试官 (总结与肯定): 你说的没错。auto 关键字本身只负责推导基础类型，而 const, *, & 这些“修饰符”，我们可以根据需要自己添加在 auto 的旁边。

  • auto a = x; -> a 是 int (一个副本)
  • const auto ca = x; -> ca 是 const int (一个常量副本)
  • auto& ra = x; -> ra 是 int& (一个引用)
  • const auto& cra = x; -> cra 是 const int& (一个常量引用)

这给了我们极大的灵活性，可以根据意图，推导出我们想要的任何变量类型。

你对 auto 的理解已经非常深入和全面了。

decltype 类型推导

面试官 (引入新概念): 好的，我们来聊聊 C++11 引入的另一个类型推导工具：decltype。

decltype 的发音是 “declared type” (声明的类型)。它和 auto 的设计哲学正好相反。

auto 是根据初始化表达式推导出一个新的、可能简化的变量类型。 而 decltype 的作用是：“请告诉我这个表达式它本身的、原封不动的类型是什么。”

请看代码：

1
2
3
4
5

const int x = 10;
const int& rx = x;

decltype(x) a;  // a 的类型是什么？
decltype(rx) b; // b 的类型是什么？

你觉得，这次 a 和 b 的类型会被推导成什么？ decltype 会像 auto 那样抛弃 const 和 & 吗？

回答：

  • 这次，a 和 b 的类型都会和用于推导的变量类型完全一致，即 a 为 const int，而 b 为 const int&。
  • 这是因为，decltype 不会像 auto 那样抛弃 const 和 &。

上面的代码还有一点需要注意：如果推导出的类型是 const int 或者 const int&，那么变量必须初始化，因为 const 类型的变量无法修改，如果没有初始化，那么后续根本无法使用，会编译报错。

面试官 (总结与肯定): 你说的完全正确。decltype 的行为就是完美复刻。

  • const int x = 10;

    • decltype(x) 推导出的类型就是 const int。
    • 所以 decltype(x) a; 等价于 const int a; (注意：const 变量必须初始化，所以这里会编译错误，但这不影响我们对类型的分析)。

  • const int& rx = x;

    • decltype(rx) 推导出的类型就是 const int&。
    • 所以 decltype(rx) b = x; 等价于 const int& b = x;。

decltype 的核心用途： 它主要用在泛型编程中，当我们想根据一个已有的变量或表达式的类型，来声明另一个新的变量或作为模板参数时。它在编写模板元编程代码时非常有用。

decltype(auto) 的用法

面试官 (最终问题): 好的，你对 auto 和 decltype 的区别已经很清楚了。

C++14 又引入了一个新东西，叫做 decltype(auto)。它看起来像是两者的结合体。

decltype(auto) 的规则很简单：

用 auto 的方式进行声明，但应用 decltype 的规则进行类型推导。

它主要用在函数返回值的类型推导上，特别是当你希望一个模板函数的返回值类型，能够完美地复刻它内部 return 语句返回的那个表达式的类型时（包括 const 和 &）。

你能否猜想一下，为什么我们需要 decltype(auto)？为什么单纯的 auto 作为函数返回值类型，在某些情况下是不够的？

（提示：考虑一个函数，它想返回一个容器中元素的引用，而不是一个副本。）

回答：

  • auto 只能返回值，即生成一个副本返回；decltype 可以完美复刻原本的类型，但无法复制值。
  • 将两者结合为 decltype(auto)，就既能复刻类型，又可以得到值，相当于完美还原了之前的变量。
  • 对需要返回引用类型变量的情况，auto 是不够的，我们就需要 decltype(auto) 了。

面试官 (解释与澄清):

auto 作为函数返回值的局限性

当 auto 用于函数返回值类型推导时，它遵循和变量声明时一样的规则——抛弃顶层的 const 和 &。

看这个例子：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

#include <string>

std::string& find_string_ref() {
    static std::string s = "hello";
    return s;
}

// 使用 auto
auto get_string_auto() {
    return find_string_ref(); // find_string_ref() 返回的是一个 string&
}
  • find_string_ref() 这个表达式，它的类型是 std::string&。
  • 但是，auto 在推导 get_string_auto 的返回值类型时，会抛弃 &。
  • 所以，get_string_auto 的返回值类型被推导成了 std::string（一个值）。
  • 这意味着，当 get_string_auto 返回时，它会创建一个 s 的副本返回给调用者。我们原本想返回一个引用的目的，失败了！

decltype(auto) 如何解决问题

decltype(auto) 的规则是：用 decltype 的规则去推导 return 语句后面的表达式的类型，然后把这个类型作为函数的返回值。

1
2
3
4

// 使用 decltype(auto)
decltype(auto) get_string_decltype_auto() {
    return find_string_ref(); // find_string_ref() 返回的是一个 string&
}
  • decltype(find_string_ref()) 推导出的类型是 std::string& (完美复刻)。
  • 所以，get_string_decltype_auto 的返回值类型被推导成了 std::string&。
  • 它成功地返回了一个引用，而不是一个副本。

总结

总结 (黄金法则):

  • auto：推导值，抛弃 const 和 &。简单方便，是绝大多数情况下的首选。
  • decltype：只“查询”表达式的类型，不做其他事。主要用于泛型编程。
  • decltype(auto)：结合了两者的语法。主要用于泛型编程和完美转发中，当你需要一个函数的返回值类型精确地、无损地匹配其 return 表达式的类型时（特别是需要保留引用属性时）。

在日常编程中，你 99% 的时间会使用 auto。decltype(auto) 则是在编写高度通用的库代码时才会遇到的“大杀器”。

今天我们深入地辨析了 C++ 中的三种类型推导机制。

  • auto 的便利性和它的 const/& 脱落规则。
  • decltype 的“完美复刻”规则。
  • 以及 decltype(auto) 如何解决 auto 在函数返回引用时的局限性。