我使用auto的一个痛苦经历是在lambda表达式中使用它:

auto i = []() { return 0; };
cout<<"i = "<<i<<endl; // output: 1 !!!

实际上，这里i被解析为int(*)()的函数指针。这只是一个简单的cout，但是想象一下，当它与template一起使用时，会导致什么样的编译/运行时错误。

你应该避免使用这样的表达式，并设置一个合适的返回类型(或受控的decltype())

上述例子的正确用法是:

auto i = []() { return 0; }(); // and now i contains the result of calling the lambda  

一件容易的事。当你不关心是什么类型时使用它。例如

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 (); ...

这里我只关心它是一个合适的迭代器，支持运算符++()，在这方面有点像鸭子类型。

此外，lambdas的类型不能拼写，因此auto f =[]…是好的风格。另一种方法是强制转换为std::function，但这会带来开销。

我真的无法想象对汽车的“滥用”。我能想到的最接近的是剥夺你自己到一些重要类型的显式转换——但你不会使用auto，你会构造一个所需类型的对象。

如果您可以在不引入副作用的情况下删除代码中的一些冗余，那么这样做一定是好的。

反例(借用别人的回答):

auto i = SomeClass();
for (auto x = make_unsigned (y); ...)

这里我们确实关心类型是什么，所以我们应该写Someclass i;And for(unsigned x = y;…

什么汽车?

它告诉编译器根据变量的初始值推断(确定)变量的数据类型。它使用类型演绎。

auto应该用在哪里?

当你对变量的类型不感兴趣时 想要使用它。 当你想要避免非常长和丑陋的typename。 当你不确定自己的类型时。 当你不想在你的代码中看到未初始化的变量。 Auto强制你初始化一个变量，因此你不能忘记做 那

当它不应该使用或缺点的自动

参考它的功能，auto可能会错误地推断类型，1 这种情况是

Std::vector<bool> vec(10,0); Auto x = vec[2]; Bool y = vec[2]; Std::cout << typeid(x).name() << "\n"; Std::cout << typeid(y).name() << "\n";

g++ 10.2上的输出令人惊讶:

St14_Bit_reference

b

如果你想让你的代码可读&，不应该使用它 对其他人来说是可以理解的。它隐藏了数据类型的可见性 来自读者。

我认为，当第一眼就不知道如何写类型，但表达式右边的类型很明显时，应该使用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)

c++程序的一个主要问题是允许你使用未初始化的变量。这导致了我们讨厌的非确定性程序行为。应该注意的是，现代编译器现在抛出适当的/message警告消息，如果程序累了使用它。

为了说明这一点，考虑下面的c++程序:

int main() {
    int x;
    int y = 0;
    y += x;
}

如果我使用现代编译器(GCC)编译这个程序，它会给出警告。这样的警告可能并非如此 如果我们使用的是真正复杂的产品代码，这是非常明显的。

main.cpp:在函数'int main()'中: Main.cpp:4:8:警告:'x'在此函数中未初始化 (-Wuninitialized) Y += x; ＾

================================================================================= 现在如果我们改变我们的程序，使用auto，然后编译，我们得到如下:

int main() {
    auto x;
    auto y = 0;
    y += x;
}

main.cpp:在函数'int main()'中: Main.cpp:2:10:错误:声明'auto x'没有初始化式 汽车x; ＾

对于auto，不可能使用未初始化的变量。如果我们开始使用auto，这是我们可以(免费)获得的主要优势。

c++专家Herb Shutter在他的CppCon14演讲中解释了这个概念和其他伟大的现代c++概念:

回归基本!现代c++风格要点

是的，它可能被过度使用而损害可读性。我建议在这样的情况下使用它:确切的类型很长，或者无法表达，或者对可读性不重要，并且变量的寿命很短。例如，迭代器类型通常很长，不重要，所以auto可以工作:

   for(auto i = container.begin(); i != container.end(); ++i);

这里的Auto不会影响可读性。

另一个例子是解析器规则类型，它可能很长很复杂。比较:

   auto spaces = space & space & space;

with

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();