在任何可能的地方都使用auto -特别是const auto，这样副作用就不那么重要了。除了一些明显的情况外，您不必担心类型，但它们仍然会为您进行静态验证，并且可以避免一些重复。在auto不可行的地方，可以使用decltype将类型语义地表示为基于表达式的契约。您的代码看起来会有所不同，但这将是一个积极的变化。

什么汽车?

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

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没有任何限制，没有遇到任何问题。有时我甚至把它用于简单的类型，如int。这使得c++对我来说是一种更高级别的语言，并且允许在c++中像在python中一样声明变量。在写完python代码之后，我有时甚至会写例如。

auto i = MyClass();

而不是

MyClass i;

这是我认为auto关键字滥用的一种情况。

Often I don't mind what is the exact type of the object, I'm more interested in its fonctionality, and as function names generally say something about the objects they return, auto does not hurt: in e.g. auto s = mycollection.size(), I can guess that s will be a kind of integer, and in the rare case where I care about the exact type, let's check the function prototype then (I mean, I prefer to have to check when I need the info, rather than a priori when code is written, just in case it would be usefull someday, as in int_type s = mycollection.size()).

关于这个例子，从公认的答案:

for ( auto x = max_size; x > 0; --x )

在我的代码中，在这种情况下我仍然使用auto，如果我想让x是unsigned，那么我使用一个实用函数，命名为say make_unsigned，这清楚地表达了我的担忧:

for ( auto x = make_unsigned(max_size); x > 0; --x )

免责声明:我只是描述我的使用，我没有能力给出建议!

在任何可能的地方都使用auto -特别是const auto，这样副作用就不那么重要了。除了一些明显的情况外，您不必担心类型，但它们仍然会为您进行静态验证，并且可以避免一些重复。在auto不可行的地方，可以使用decltype将类型语义地表示为基于表达式的契约。您的代码看起来会有所不同，但这将是一个积极的变化。

我指出的一个危险是在引用方面。 如。

MyBigObject& ref_to_big_object= big_object;
auto another_ref = ref_to_big_object; // ?

问题是，在这种情况下，another_ref实际上不是一个引用，它是MyBigObject而不是MyBigObject&。你最终复制了一个大对象而没有意识到它。

如果你直接从一个方法中得到一个引用，你可能不会考虑它实际上是什么。

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

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++风格要点