我一直在使用C++11标准中提供的新关键字auto来处理复杂的模板类型，我认为这就是它的设计初衷。但我也在将其用于以下情况：
auto foo = std::make_shared<Foo>();
更加怀疑的是:
auto foo = bla(); // where bla() return a shared_ptr<Foo>
我还没有看到关于这个话题的太多讨论。似乎auto可能被过度使用，因为类型通常是文档和健全性检查的一种形式。在使用auto时，你会在哪里划线，以及对于这个新特性的推荐用例是什么？
澄清一下：我不是在寻求哲学上的观点；我正在询问标准委员会对这个关键字的预期用途，可能还有关于如何在实践中实现这个预期用途的评论。
我认为在难以一眼确定类型的情况下，应该使用auto关键字，但表达式右侧的类型是显而易见的。例如，使用：
my_multi_type::nth_index<2>::type::key_type::composite_key_type::
key_extractor_tuple::tail_type::head_type::result_type
boost::multi_index中获取复合键类型，即使您知道它是int，也不能只写int，因为它将来可能会更改。在这种情况下，我会写auto。auto关键字在特定情况下提高了可读性，则使用它。当读者明确知道auto代表的类型时，可以写auto。auto foo = std::make_shared<Foo>(); // obvious
auto foo = bla(); // unclear. don't know which type `foo` has
const size_t max_size = 100;
for ( auto x = max_size; x > 0; --x ) // unclear. could lead to the errors
// since max_size is unsigned
std::vector<some_class> v;
for ( auto it = v.begin(); it != v.end(); ++it )
// ok, since I know that `it` has an iterator type
// (don't really care which one in this context)
bla() 返回什么，你都将其传递给了 foo。 - Luis Machuca尽可能使用 auto —— 特别是 const auto，这样副作用就不太需要担忧了。你不必担心类型问题，除非是显而易见的情况，但类型仍然会被静态验证，并且可以避免一些重复。在无法使用 auto 的情况下，可以使用 decltype 来表达语义上基于表达式的 约定 类型。你的代码看起来会有所不同，但这是积极的变化。
很简单。当你不关心类型是什么时，就使用它。例如
for (const auto & i : some_container) {
...
我在这里关心的只是i是容器中的任何内容。
这有点像typedefs。
typedef float Height;
typedef double Weight;
//....
Height h;
Weight w;
在这里，我不关心h和w是浮点数还是双精度浮点数，只需要它们是适合表示身高和体重的任何类型。
或者考虑
for (auto i = some_container .begin (); ...
我关心的是一个适合的迭代器，支持operator++()，这在某种程度上类似于鸭子类型。
此外，lambda表达式的类型无法显式表示，因此使用auto f = []...是一种好的风格。另一种选择是将其转换为std::function，但会带来额外的开销。
我真的想不出什么“滥用”auto的例子。我能想到的最接近的是放弃对某些重要类型的显式转换 - 但你不会使用auto来实现，你会构造一个期望类型的对象。
反例（借用别人的回答）：
auto i = SomeClass();
for (auto x = make_unsigned (y); ...)
在这里我们关心类型，因此我们应该写成Someclass i;和for(unsigned x = y;...
auto 关键字可以用于函数模板中的参数类型推断。 - Anderson Green在C++ and Beyond 2012的Ask Us Anything面板上，Andrei Alexandrescu、Scott Meyers和Herb Sutter之间有一个精彩的交流，谈论何时使用和不使用auto。跳到第25:03分钟，进行4分钟的讨论。三位演讲者都提出了应该记在心中的优秀观点，以便在何时不使用auto。
我强烈鼓励人们自己得出结论，但我的理解是要在任何地方都使用auto除非：
大量使用explicit可以帮助减少对后者的担忧，从而减少前者成为问题的时间。
auto。了解X、Y和Z是什么，然后在其他地方都使用auto。”尽情使用吧。在编写代码时，只要方便，就可以随处使用auto。
任何语言中的新功能都会被一些类型的程序员过度使用。只有经验丰富的程序员（不是新手）通过适度的过度使用，才能使其他经验丰富的程序员学会正确使用的范围。极端的过度使用通常是不好的，但也可能是好的，因为这种过度使用可能会导致改进该功能或更好地替换它。
但如果我正在处理超过几行的代码，则会考虑根据需要显式指定类型，因为这样可以提高可读性和维护性。
auto foo = bla();
在类型不被明确指定的情况下，我可能会想要修改这些行以包含类型。第一个例子非常好，因为类型只被声明了一次，auto让我们避免了两次写杂乱的模板类型。太棒了C++++。但是，如果类型在附近的代码中没有很容易地显示出来，那么在C++及其直接的后继语言中，显示零次类型会让我感到紧张。对于其他设计用于更高级别抽象、多态性和通用性的语言，这样做则是可以接受的。
是的，过度使用它会影响可读性。我建议在以下情况下使用它：当确切类型很长、难以念出或者对可读性不重要，并且变量的生命周期短暂时。例如，迭代器类型通常很长并且不重要，因此可以使用 auto：
for(auto i = container.begin(); i != container.end(); ++i);
auto在这里不会影响可读性。
另一个例子是解析器规则类型，可能会变得冗长和复杂。比较一下：
auto spaces = space & space & space;
使用
r_and_t<r_and_t<r_char_t<char>&, r_char_t<char>&>, r_char_t<char>&> spaces =
space & space & space;
另一方面，当类型已知且简单时，最好明确地声明它：
int i = foo();
与其说
auto i = foo();
r_and_t<r_and_t<r_char_t<char>&, r_char_t<char>&>, r_char_t<char>&> 是什么意思？ - Dennis Zickefoosespace的类型，并搜索相关信息。这是更有用的信息...毕竟，问题不是“这个新变量的类型是什么”，而是“space & space & space是什么意思？”表达式的实际类型只是噪音。 - Dennis Zickefooseauto 在与表达式模板结合使用时可能非常危险，这在线性代数库（如Eigen或OpenCV）中经常使用。
auto A = Matrix(...);
auto B = Matrix(...);
auto C = A * B; // C is not a matrix. It is a matrix EXPRESSION.
cout << C; // The expression is evaluated and gives the expected result.
... // <code modifying A or B>
cout << C; // The expression is evaluated AGAIN and gives a DIFFERENT result.
由于这类型错误所导致的Bug非常难以调试。如果你一定要使用从左至右声明风格中的auto，那么一个可能的解决方法是显式地将结果转换为期望的类型。
auto C = Matrix(A * B); // The expression is now evaluated immediately.
A*B表达式是复制到auto变量还是其他地方，您所描述的行为仍然存在。 - xtoflauto 关键字的 bug 是由它引起的。 - Jim Balterdiag(A * B)不必浪费计算非对角线元素的周期。 - Ben Voigt我不受限制地使用auto，也没有遇到任何问题。有时候我甚至会在简单类型（如int）中使用它。这使得C++对我来说更像是一种高级语言，并允许像Python一样声明变量。在编写Python代码后，我甚至有时会写例如：
auto i = MyClass();
而不是
MyClass i;
这是一个例子，我认为在这种情况下滥用auto关键字。
通常我并不关心对象的确切类型，而更关心它的功能。由于函数名称通常会描述它们返回的对象类型，因此auto并不会有什么问题：例如，在auto s = mycollection.size()中，我可以猜测s将是某种整数类型，而在少见的情况下，如果我需要了解确切的类型，我们可以检查函数原型（我的意思是，我更喜欢在需要信息时再进行检查，而不是在编写代码之前就提前检查一遍，以防万一会在某些时候派上用场，如int_type s = mycollection.size()）。
关于来自已接受答案的示例：
for ( auto x = max_size; x > 0; --x )
在我的代码中，我仍然在这种情况下使用auto，如果我想让x是无符号的，那么我会使用一个实用函数，名为make_unsigned，它清楚地表达了我的顾虑：
for ( auto x = make_unsigned(max_size); x > 0; --x )
免责声明：我只是描述了我的使用情况，我没有资格给出建议！
auto i = MyClass()。 - rafakC++程序的一个主要问题是它允许使用未初始化的变量，这会导致令人讨厌的不确定性程序行为。需要注意的是，现代编译器现在会抛出适当/消息警告信息，如果程序试图使用它。
只是为了说明这一点，考虑下面的C++程序：
int main() {
int x;
int y = 0;
y += x;
}
main.cpp: In function 'int main()':
main.cpp:4:8: warning: 'x' is used uninitialized in this function [-Wuninitialized]
y += x;
^
================================================================================= 现在，如果我们更改使用auto的程序，然后编译，我们将得到以下结果：
int main() {
auto x;
auto y = 0;
y += x;
}
使用auto关键字，可以避免使用未初始化的变量。如果我们开始使用auto，那么这是一个重要的优势（免费获得）。C++专家Herb Shutter在他的CppCon14演讲中解释了这个概念和其他伟大的现代C++概念：main.cpp: In function 'int main()':
main.cpp:2:10: error: declaration of 'auto x' has no initializer
auto x; ^
auto。 - Lightness Races in Orbitauto - 但你不需要它来避免这个问题。 - einpoklum我注意到的一个危险是参考文献方面。
例如：
MyBigObject& ref_to_big_object= big_object;
auto another_ref = ref_to_big_object; // ?
auto another_ref = function_returning_ref_to_big_object();
如果您需要，可以使用"auto&"或"const auto&"
MyBigObject& ref_to_big_object= big_object;
auto& another_ref = ref_to_big_object;
const auto& yet_another_ref = function_returning_ref_to_big_object();
auto关键字，则应该知道它的正确使用方式。作为一个新手，我想知道应该如何使用它？ - Alan Turingvar关键字后，我在很多地方看到过有关此话题的讨论（也就是当人们克服了它并非动态类型的想法后）。如果你愿意，可以从这个问题开始，并查看相关问题。 - R. Martinho Fernandesauto的良好和不良使用的清晰代码片段。并非所有问题都是问2+2等简单问题。例如，询问如何计算2+2仍然是一个好问题，但你可以轻易地称之为“主观”。也许我太天真了，但对我来说，如果一个问题导致了一个有用的澄清回答，那么问题和答案都应该在网站上。 - Alan Turingauto foo = bla();为“不好”显然是一种观点，而不是事实，这使得这个问题和答案成为了一个讨论，这也使得它与Programmers SE相关，这正是关闭投票所表明的。/耸肩 - ildjarn