`auto` 说明符的编译时间是否较慢？
Is `auto` specifier slower in compilation time?
从 C++11 开始，我们可以使用 auto a = 1+2 而不是 int a = 1+2，并且编译器会自行推断 a 的类型。它是如何工作的？在编译时（更多操作）是否比自己声明类型慢？
auto 要求 C++11 编译器 做一些 limited 类型的 type inference (look into Ocaml 如果你想要一些更性感的类型推理语言）。但开销仅为 compile-time。
如果将auto a=1+2;替换为int a=1+2;（两者含义相同，参见answer by simplicis) and if you ask your compiler to optimize (and probably even without asking for optimizations) you'll probably get the same machine code. See also this。
如果使用 GCC 尝试用 g++ -Wall -fverbose-asm -O -S foo.cc 编译一个小的 C++11 foo.cc 文件并查看（使用编辑器）生成的 foo.s 汇编文件.您将看不到生成的代码有什么不同（但汇编程序文件可能会略有变化，例如由于调试信息等元数据）
如果您担心 速度变慢 compile-time 我想使用 auto 不是决定性因素（可能，重载在编译中的成本更高时间）。 C++11 几乎被设计为实际上 需要 大量 optimizations（特别是复杂的内联和常量折叠以及死代码消除），并且它的 "parsing"（值得注意的是 header 包含和模板扩展）是昂贵的。
Precompiling headers and parallel builds with make -j (and perhaps ccache 或 distcc) 比避免 auto.
可能有助于缩短整体编译时间
并且如果您想系统地避免 auto（特别是在 range-for loops like std::map<std::string,int> dict; for (auto it: dict) {...}) you'll end up typing much more source code (whose parsing and checking takes significant time) with more risks of error. As explained here 中，您可能会稍微错误地猜测类型，并且（稍微错误地）显式它可能会减慢代码的执行速度因为有额外的转化。
如果使用 GCC，您可以将 -ftime-report 传递给 g++ 并获取有关各种 GCC 遍历和阶段的时间测量值。
它是如何工作的：
来自ISO/IEC:
...The auto specifier is a placeholder for a type to be deduced (7.1.6.4). The other simple-type-specifiers specify
either a previously-declared user-defined type or one of the fundamental types...
7.1.6.4 自动说明符
- The auto type-specifier signifies that the type of a variable being declared shall be deduced from its initializer
or that a function declarator shall include a trailing-return-type.
- The auto type-specifier may appear with a function declarator with a trailing-return-type in any
context where such a declarator is valid.
- Otherwise, the type of the variable is deduced from its initializer. The name of the variable being declared
shall not appear in the initializer expression. This use of auto is allowed when declaring variables in a
block, in namespace scope, and in a for-init-statement; auto shall appear as one of the decl-specifiers in the decl-specifier-seq and the decl-specifier-seq shall be followed by one or more initdeclarators, each of which shall have a non-empty initializer...
示例：
auto x = 5; // OK: x has type int
const auto *v = &x, u = 6; // OK: v has type const int*, u has type const int
static auto y = 0.0; // OK: y has type double
auto int r; // error: auto is not a storage-class-specifier
是否更快：
简单的答案是是，通过使用它可以省略很多类型转换，但是，如果使用不当，它可能会成为错误的重要来源。
在 Bjarne Stroustrup 的一次采访中，他说 auto 关键字为编码人员和编译器实现人员带来了双赢局面。
编译器知道表达式（如1 + 2）的计算结果类型。这就是语言的工作方式——两个操作数都是 int 类型，所以结果也是 int。使用 auto a，您只是告诉编译器 "use the type of the initializing expression".
编译器不必在这里做任何额外的工作或推导。 auto 关键字只是减轻了 you 计算表达式和编写正确类型的负担。 （您可能会弄错，可能会产生意想不到的副作用——请参阅 (and the ）示例 auto 如何避免意想不到的 运行 时间转换和复制。
auto 关键字在迭代器中真正发挥作用：
std::vector< std::string >::const_iterator it = foo.cbegin();
对比
auto it = foo.cbegin();
从 C++11 开始，我们可以使用 auto a = 1+2 而不是 int a = 1+2，并且编译器会自行推断 a 的类型。它是如何工作的？在编译时（更多操作）是否比自己声明类型慢？
auto 要求 C++11 编译器 做一些 limited 类型的 type inference (look into Ocaml 如果你想要一些更性感的类型推理语言）。但开销仅为 compile-time。
如果将auto a=1+2;替换为int a=1+2;（两者含义相同，参见answer by simplicis) and if you ask your compiler to optimize (and probably even without asking for optimizations) you'll probably get the same machine code. See also this。
如果使用 GCC 尝试用 g++ -Wall -fverbose-asm -O -S foo.cc 编译一个小的 C++11 foo.cc 文件并查看（使用编辑器）生成的 foo.s 汇编文件.您将看不到生成的代码有什么不同（但汇编程序文件可能会略有变化，例如由于调试信息等元数据）
如果您担心 速度变慢 compile-time 我想使用 auto 不是决定性因素（可能，重载在编译中的成本更高时间）。 C++11 几乎被设计为实际上 需要 大量 optimizations（特别是复杂的内联和常量折叠以及死代码消除），并且它的 "parsing"（值得注意的是 header 包含和模板扩展）是昂贵的。
Precompiling headers and parallel builds with make -j (and perhaps ccache 或 distcc) 比避免 auto.
并且如果您想系统地避免 auto（特别是在 range-for loops like std::map<std::string,int> dict; for (auto it: dict) {...}) you'll end up typing much more source code (whose parsing and checking takes significant time) with more risks of error. As explained here 中，您可能会稍微错误地猜测类型，并且（稍微错误地）显式它可能会减慢代码的执行速度因为有额外的转化。
如果使用 GCC，您可以将 -ftime-report 传递给 g++ 并获取有关各种 GCC 遍历和阶段的时间测量值。
它是如何工作的：
来自ISO/IEC:
...The auto specifier is a placeholder for a type to be deduced (7.1.6.4). The other simple-type-specifiers specify either a previously-declared user-defined type or one of the fundamental types...
7.1.6.4 自动说明符
- The auto type-specifier signifies that the type of a variable being declared shall be deduced from its initializer or that a function declarator shall include a trailing-return-type.
- The auto type-specifier may appear with a function declarator with a trailing-return-type in any context where such a declarator is valid.
- Otherwise, the type of the variable is deduced from its initializer. The name of the variable being declared shall not appear in the initializer expression. This use of auto is allowed when declaring variables in a block, in namespace scope, and in a for-init-statement; auto shall appear as one of the decl-specifiers in the decl-specifier-seq and the decl-specifier-seq shall be followed by one or more initdeclarators, each of which shall have a non-empty initializer...
示例：
auto x = 5; // OK: x has type int
const auto *v = &x, u = 6; // OK: v has type const int*, u has type const int
static auto y = 0.0; // OK: y has type double
auto int r; // error: auto is not a storage-class-specifier
是否更快：
简单的答案是是，通过使用它可以省略很多类型转换，但是，如果使用不当，它可能会成为错误的重要来源。
在 Bjarne Stroustrup 的一次采访中，他说 auto 关键字为编码人员和编译器实现人员带来了双赢局面。
编译器知道表达式（如1 + 2）的计算结果类型。这就是语言的工作方式——两个操作数都是 int 类型，所以结果也是 int。使用 auto a，您只是告诉编译器 "use the type of the initializing expression".
编译器不必在这里做任何额外的工作或推导。 auto 关键字只是减轻了 you 计算表达式和编写正确类型的负担。 （您可能会弄错，可能会产生意想不到的副作用——请参阅 auto 如何避免意想不到的 运行 时间转换和复制。
auto 关键字在迭代器中真正发挥作用：
std::vector< std::string >::const_iterator it = foo.cbegin();
对比
auto it = foo.cbegin();