为什么我需要显式编写'auto'关键字？

Question

我正在从 C++98 转向 C++11，并且已经熟悉了 auto 关键字。我想知道如果编译器能够自动推断类型，为什么我们需要显式声明auto。我知道 C++ 是一种强类型语言，这是一个规则，但是如果不显式声明变量 auto 就不可能达到相同的结果吗？

Answer 1

删除显式 auto 会破坏语言：

例如

int main()
{
    int n;
    {
        auto n = 0; // this shadows the outer n.
    }
}

您可以看到删除auto 不会遮蔽外部n。

Answer 2

您的问题有两种解释：

• 为什么我们需要“自动”？我们不能直接放弃吗？
• 为什么我们必须使用自动？如果没有给出，我们不能让它隐含吗？

Bathsheba answered 第一个解释很好，第二个解释如下（假设目前不存在其他声明；假设有效的 C++）：

int f();
double g();

n = f(); // declares a new variable, type is int;
d = g(); // another new variable, type is double

if(n == d)
{
    n = 7; // reassigns n
    auto d = 2.0; // new d, shadowing the outer one
}

它会是可能的，其他语言可以很好地解决（好吧，除了阴影问题之外）......但在 C++ 中并非如此，问题（在第二种解释的意义）现在是：为什么？

这一次，答案不像第一个解释那样明显。不过有一点很明显：对关键字的明确要求使语言更安全（我不知道这是否是促使语言委员会做出决定的原因，但它仍然是一个重点）：

grummel = f();

// ...

if(true)
{
    brummel = f();
  //^ uh, oh, a typo...
}

我们可以就此达成一致，不需要任何进一步的解释吗？

不要求 auto 更大的危险，[然而]，它意味着在远离函数的地方（例如在头文件中）添加一个全局变量可能会改变原本的声明将该函数中的局部范围变量转换为对全局变量的赋值...具有潜在的灾难性（当然也非常令人困惑）的后果。

_{（引用 psmears' 评论，因为它的重要性 - 感谢您的提示）}

Answer 3

如果不明确声明变量auto，就不可能达到相同的结果吗？

我将稍微改一下你的问题，以帮助你理解为什么需要auto：

如果不显式使用类型占位符，是否不可能实现相同的结果？

这不是可能吗？当然这是“可能的”。问题是这样做是否值得。

其他语言中没有类型名的大多数语法以两种方式之一工作。有类似 Go 的方式，name := value; 声明一个变量。还有一种类似 Python 的方式，如果 name 之前没有声明过，name = value; 声明一个新变量。

让我们假设在 C++ 中应用这两种语法都没有语法问题（尽管我已经看到 identifier 后跟 : 在 C++ 中的意思是“制作标签”）。那么，与占位符相比，你失去了什么？

好吧，我不能再这样做了：

auto &name = get<0>(some_tuple);

看，auto 总是意味着“价值”。如果您想获得参考，您需要明确使用&。如果赋值表达式是纯右值，它将正确地无法编译。这两种基于赋值的语法都无法区分引用和值。

现在，如果给定值是引用，您可以使此类赋值语法推断引用。但这意味着你不能这样做：

auto name = get<0>(some_tuple);

这复制元组，创建一个独立于some_tuple的对象。有时，这正是你想要的。如果您想从带有auto name = get<0>(std::move(some_tuple)); 的元组中移动，这将更加有用。

好的，所以也许我们可以稍微扩展一下这些语法来解释这种区别。也许&name := value; 或&name = value; 意味着推断出像auto& 这样的引用。

好的，好的。这个呢：

decltype(auto) name = some_thing();

哦，没错； C++ 实际上有two placeholders: auto and decltype(auto)。这个推论的基本思想是它的工作原理就像你做了decltype(expr) name = expr;一样。所以在我们的例子中，如果some_thing() 是一个对象，它就会推导出一个对象。如果some_thing()是一个引用，它会推导出一个引用。

当您在模板代码中工作并且不确定函数的返回值究竟是什么时，这非常有用。这对于转发来说非常有用，它是一个必不可少的工具，即使它没有被广泛使用。

所以现在我们需要在语法中添加更多内容。 name ::= value; 的意思是“做decltype(auto) 所做的事情”。我没有 Pythonic 变体的等价物。

看看这个语法，是不是很容易意外输入错误？不仅如此，它几乎不是自我记录的。即使您以前从未见过decltype(auto)，它也足够大且足够明显，您至少可以很容易地看出发生了一些特别的事情。而::= 和:= 之间的视觉差异很小。

但那是意见的东西；还有更多实质性问题。看，所有这些都是基于使用赋值语法。嗯...那些你不能使用赋值语法的地方呢？像这样：

for(auto &x : container)

我们是否将其更改为for(&x := container)？因为这似乎与基于范围的for 说非常不同的东西。看起来它是来自常规 for 循环的初始化语句，而不是基于范围的 for。它也将是与非推导案例不同的语法。

此外，复制初始化（使用 =）在 C++ 中与直接初始化（使用构造函数语法）不同。所以name := value; 在auto name(value) 可以使用的情况下可能不起作用。

当然，您可以声明 := 将使用直接初始化，但这与 C++ 其余部分的行为方式完全不一致。

此外，还有一件事：C++14。它为我们提供了一个有用的推导功能：返回类型推导。但这是基于占位符的。与基于范围的for 非常相似，它基本上基于编译器填充的类型名，而不是应用于特定名称和表达式的某些语法。

你看，所有这些问题都来自同一个来源：你正在发明全新的语法来声明变量。基于占位符的声明不必发明新的语法。他们使用与以前完全相同的语法；他们只是使用了一个新的关键字，它的作用类似于一种类型，但具有特殊的含义。这就是允许它在基于范围的for 和返回类型推导中工作的原因。它允许它有多种形式（auto vs. decltype(auto)）。以此类推。

占位符之所以有效，是因为它们是解决问题的最简单方法，同时保留了使用实际类型名称的所有好处和通用性。如果您想出另一种与占位符一样通用的替代方案，那么它就不太可能像占位符那样简单。

除非它只是用不同的关键字或符号拼写占位符...

Answer 4

简而言之：auto 在某些情况下可能会被删除，但这会导致不一致。

首先，正如所指出的，C++ 中的声明语法是<type> <varname>。显式声明需要某种类型或至少有一个声明关键字。所以我们可以使用var <varname> 或declare <varname> 之类的，但auto 是C++ 中长期存在的关键字，是自动类型推断关键字的理想候选。

是否可以通过赋值隐式声明变量而不破坏一切？

有时是的。您不能在函数外部执行赋值，因此您可以在此处使用赋值语法进行声明。但是这样的做法会带来语言的不一致，可能会导致人为错误。

a = 0; // Error. Could be parsed as auto declaration instead.
int main() {
  return 0;
}

当涉及到任何类型的局部变量时，显式声明是它们控制变量范围的方式。

a = 1; // use a variable declared before or outside
auto b = 2; // declare a variable here

如果允许使用模棱两可的语法，声明全局变量可能会突然将局部隐式声明转换为赋值。查找这些转化需要检查所有内容。并且为了避免冲突，您需要为所有全局变量提供唯一名称，这会破坏作用域的整个想法。所以真的很糟糕。

Answer 5

auto 是一个关键字，您可以在通常需要指定类型的地方使用它。

  int x = some_function();

可以通过自动推导出int 类型来使其更通用：

  auto x = some_function();

所以这是对语言的保守扩展；它适合现有的语法。没有它x = some_function() 就变成了一个赋值语句，不再是一个声明。

Answer 6

语法必须明确且向后兼容。

如果 auto 被删除，将无法区分语句和定义。

auto n = 0; // fine
n=0; // statememt, n is undefined.

Answer 7

除了之前的答案，还有一个老屁的额外说明：看起来您可能认为能够在不以任何方式声明的情况下开始使用新变量是一种优势。

在可能隐式定义变量的语言中，这可能是一个大问题，尤其是在较大的系统中。你打了一个错字，调试了几个小时才发现你无意中引入了一个值为零（或更糟）的变量 - blue vs bleu，label vs lable ...结果是你如果不彻底检查精确的变量名，就无法真正信任任何代码。

只需使用auto 就可以告诉编译器和维护者您打算声明一个新变量。

想一想，为了避免这种噩梦，FORTRAN 中引入了“隐式无”语句 - 现在您会看到它在所有严肃的 FORTRAN 程序中都使用过。没有它简直……可怕。