C++ 用C+，多少是太多+；11自动关键字？

我一直在使用C++11标准中提供的新的

auto

关键字来处理复杂的模板类型，我相信这就是它的设计目的。但我也在使用它，比如：

auto foo = std::make_shared<Foo>();

auto foo=std:：make_shared（）；

更值得怀疑的是：

auto foo = bla(); // where bla() return a shared_ptr<Foo>

auto-foo=bla（）；//其中bla（）返回一个共享的\u ptr

关于这个话题我没有看到太多的讨论。似乎

auto

可能被过度使用，因为类型通常是文档和健全性检查的一种形式。在使用

auto

时，您的底线在哪里？对于此新功能，建议使用哪些用例

澄清一下：我不是在征求哲学观点；我想问一下标准委员会对这个关键词的预期用途，可能是关于如何在实践中实现预期用途的评论

---

旁注：这个问题转移到了SE.Programmers，然后又回到了Stack Overflow。关于这一点的讨论可以在这里找到。

我认为，当很难说如何一眼就能写出类型时，应该使用

auto

关键字，但表达式右侧的类型是显而易见的。例如，使用：

my_multi_type::nth_index<2>::type::key_type::composite_key_type::
    key_extractor_tuple::tail_type::head_type::result_type

---

使用

auto

可以推断类型。如果您知道某个东西是整数，或者您知道它是字符串，那么只需使用int/std:：string等。我不会担心“过度使用”语言特性，除非它达到可笑的程度，或者混淆代码

---

无论如何，这是我的意见。

去做吧。使用

auto

可以简化代码编写的任何地方

任何语言中的每一个新特性都会被至少某些类型的程序员过度使用。只有通过一些有经验的程序员（不是noob）的适度过度使用，其他有经验的程序员才能学会正确使用的界限。过度使用通常是不好的，但也可能是好的，因为这种过度使用可能会导致功能的改进或更好的功能来取代它

但是如果我在编写代码时使用的代码不止几行，比如

auto foo = bla();

---

如果类型指示零次，我可能希望更改这些行以包括类型。第一个示例非常好，因为类型只声明了一次，

auto

使我们不必编写两次杂乱的模板类型。C++万岁。但是如果不在附近的线路上清晰可见，那么它就显得非常紧张，至少在C++和它的直接继承者中是如此。对于其他设计用于更高层次、更抽象、更多态和更泛型的语言来说，这没关系。

是的，它可能被过度使用，从而损害可读性。我建议在精确类型很长，或者无法表达，或者对可读性不重要，变量很短的情况下使用它。例如，迭代器类型通常很长，并不重要，因此

auto

可以工作：

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

auto

这里不会影响可读性

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

   auto spaces = space & space & space;

与

而不是

auto i = foo();

---

我在

auto

方面的一个痛苦经历是：

---

可以在任何地方使用

auto

，尤其是

const auto

，这样副作用就不那么重要了。除了明显的情况外，您不必担心类型，但它们仍然会为您进行静态验证，并且您可以避免一些重复。如果

auto

不可行，可以使用

decltype

将类型语义表示为基于表达式的契约。您的代码看起来会有所不同，但这将是一个积极的变化。

我使用的

auto

没有任何限制，也没有遇到任何问题。有时我甚至会将它用于像

int

这样的简单类型。这使得C++成为我的高级语言，并允许在Python中声明C++中的变量。在编写python代码之后，我甚至有时会编写

auto i = MyClass();

而不是

MyClass i;

这是一种滥用

auto

关键字的情况

通常我不在乎对象的确切类型，我更感兴趣的是它的功能性，因为函数名通常会说明它们返回的对象，

auto

没有什么坏处：例如在

auto s=mycollection.size（）

中，我可以猜测

s

将是一种整数，在我很少关心确切类型的情况下，让我们检查一下函数原型（我的意思是，我更喜欢在需要信息时检查，而不是在编写代码时先检查，以防有一天它会有用，如

int\u type s=mycollection.size（）

）

关于接受答案中的这个例子：

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

在我的代码中，在这种情况下，我仍然使用

auto

，如果我希望

x

无符号，那么我使用一个名为say

make_unsigned

的实用函数，它清楚地表达了我的担忧：

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

---

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

auto

关键字只能用于局部变量，不能用于参数或类/结构成员。因此，在你喜欢的任何地方使用它们都是安全可行的。我确实经常使用它们。类型是在编译时推导出来的，调试器在调试时显示类型，

sizeof

会正确地报告它，

decltype

会给出正确的类型-没有任何危害。我从不认为

auto

使用过度

简单。当你不在乎类型是什么时使用它。比如说

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

这里我所关心的是它是一个合适的迭代器，supporti

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

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

for (const auto & i : some_container) {
   ...

typedef float Height;
typedef double Weight;
//....
Height h;
Weight w;

for (auto i = some_container .begin (); ...

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

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

auto another_ref = function_returning_ref_to_big_object();

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

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

    ^

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

 auto x;

      ^

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.

auto C = Matrix(A * B); // The expression is now evaluated immediately.

auto x = f();

auto nugget = mine_gold();