auto 关键字的含义是什么？

Question

据我所知，auto 一直是一个奇怪的存储类说明符，没有任何用途。

但是，我已经尝试了 auto 的作用，并且它假定了我分配给它的任何类型！ auto 使涉及迭代器和许多其他内容的代码更容易编写。

从什么时候开始可以使用这个关键字？它是 Visual C++ 扩展吗？

Answer 1

auto 是 C++ 从 C 中“继承”的一个关键字，它几乎一直存在，但实际上从未使用过，因为只有两种可能的情况：要么不允许，要么被假定为默认。

使用 auto 来表示推导类型是 C++11 中的新功能。

同时，auto x =initializer 从 initializer 的类型推导 x 的类型，就像函数的模板类型推导一样模板。考虑这样的函数模板：

template<class T>
int whatever(T t) { 
    // point A
};

在 A 点，已根据传递给 whatever 的参数值将类型分配给 T。当您执行 auto x =initializer; 时，会使用相同的类型推导从用于的 initializer 类型确定 x 的类型初始化它。

这意味着编译器实现 auto 所需的大多数类型推导机制已经存在，并用于任何尝试实现 C++98/03 的编译器上的模板。因此，对于几乎所有编译器团队来说，添加对 auto 的支持显然相当容易——添加得相当快，而且似乎也很少有与之相关的错误。

当这个答案最初写出来时（2011 年，在 C++ 11 标准墨迹未干之前），auto 已经相当可移植了。如今，它在所有主流编译器中都是完全可移植的。避免它的唯一明显的原因是，如果您需要编写与 C 编译器兼容的代码，或者您有特定的需要针对某些您知道不支持它的利基编译器（例如，有些人仍然编写代码）对于使用 Borland、Watcom 等编译器的 MS-DOS，几十年来没有出现重大升级）。如果您使用的是任何主流编译器的最新版本，则完全没有理由避免它。

该标准的最新修订添加了一些可以使用 auto 的新位置。从 C++14 开始，您可以使用 auto 作为 lambda 的参数类型：

    [](auto s) { return s + 1; }

这基本上与上面的示例执行相同的操作 - 尽管它没有显式使用 template 语法，这基本上是一个模板，它推断参数的类型，并在该类型上实例化模板。

这非常方便且有用，在 C++20 中，为普通函数（而不仅仅是 lambda）添加了相同的功能。

但是，就像之前一样，所有这些实际上都归结为使用与自 C++98 以来的函数模板相同的基本类型推导机制。 auto 允许在更多地方、更方便地使用它，但底层的繁重工作保持不变。

Answer 2

它只是采用一个通常无用的关键字并赋予它一个新的、更好的功能。它是 C++11 中的标准，大多数支持 C++11 的 C++ 编译器都会支持它。

Answer 3

对于变量，指定正在声明的变量的类型将从其初始值设定项自动推导。对于函数，指定返回类型是尾随返回类型或将从其返回语句推导出来 (C++14 起)。

语法

auto variable initializer   (1) (since C++11)

auto function -> return type    (2) (since C++11)

auto function   (3) (since C++14)

decltype(auto) variable initializer (4) (since C++14)

decltype(auto) function (5) (since C++14)

auto :: (6) (concepts TS)

cv(optional) auto ref(optional) parameter   (7) (since C++14)

说明

1. 在块作用域、命名空间作用域、for 循环的初始化语句等中声明变量时，可以使用关键字 auto 作为类型说明符。

   一旦确定了初始值设定项的类型，编译器就会使用函数调用中的模板参数推导规则来确定将替换关键字 auto 的类型（有关详细信息，请参阅模板参数推导#其他上下文）。关键字 auto 可能会附带修饰符，例如 const 或 &，这些修饰符将参与类型推导。例如，给定 const auto& i = expr;，i的类型正是假想模板template中参数u的类型void f(const U& u) 如果函数调用 f(expr) 已编译。因此，汽车&&可以根据初始化器推导为左值引用或右值引用，用于基于范围的 for 循环。

   如果使用 auto 声明多个变量，则推导的类型必须匹配。例如，声明 auto i = 0, d = 0.0; 格式错误，而声明 auto i = 0, *p = &i; 格式良好-formed 并且 auto 被推导为 int。

2. 在使用尾随返回类型语法的函数声明中，关键字 auto 不执行自动类型检测。它仅作为语法的一部分。

3. 在不使用尾随返回类型语法的函数声明中，关键字 auto 指示将使用模板参数推导规则从其 return 语句的操作数推导返回类型。

4. 如果变量的声明类型为decltype(auto)，则关键字auto将被替换为其初始值设定项的表达式（或表达式列表），并使用以下规则推导出实际类型decltype。

5. 如果函数的返回类型被声明为decltype(auto)，则关键字auto将被其return语句的操作数替换，并使用decltype的规则推导出实际的返回类型。

6. 形式为 auto:: 的嵌套名称说明符是一个占位符，它被替换为遵循约束类型占位符推导规则的类或枚举类型。

7. lambda 表达式中的参数声明。 (C++14 起) 函数参数声明。 （概念 TS）

注释

在 C++11 之前，auto 具有存储持续时间说明符的语义。
在一个声明中混合自动变量和函数，如 auto f() -> int, i = 0; 是不允许的。

欲了解更多信息： http://en.cppreference.com/w/cpp/language/auto

Answer 4

auto关键字是C++中一个重要且经常使用的关键字。在初始化变量时，auto关键字用于类型推断（也称为类型推导）。

关于 auto 关键字有 3 种不同的规则。

第一条规则

auto x = expr; ---->没有指针或引用，只有变量名。在这种情况下，const 和引用将被忽略。

int  y = 10;
int& r = y;
auto x = r; // The type of variable x is int. (Reference Ignored)

const int y = 10;
auto x = y; // The type of variable x is int. (Const Ignored)

int y = 10;
const int& r = y;
auto x = r; // The type of variable x is int. (Both const and reference Ignored)

const int a[10] = {};
auto x = a; //  x is const int *. (Array to pointer conversion)

Note : When the name defined by auto is given a value with the name of a function,
       the type inference will be done as a function pointer.

第二条规则

auto& y = expr; 或 auto* y = expr; ----> ----> auto 关键字后的引用或指针。

警告：此规则中不会忽略 const ！ 。

int y = 10;
auto& x = y; // The type of variable x is int&.

警告：在此规则中，不会发生数组到指针的转换（数组衰减）！

auto& x = "hello"; // The type of variable x is  const char [6].

static int x = 10;
auto y = x; // The variable y is not static.Because the static keyword is not a type. specifier 
            // The type of variable x is int.

第三条规则

auto&& z = expr; ---->这不是右值引用。

警告：如果类型推断有问题并且 &&使用令牌，名称
像这样引入的称为“转发参考”（也称为通用参考）。

auto&& r1 = x; // The type of variable r1 is int&.Because x is Lvalue expression. 

auto&& r2 = x+y; // The type of variable r2 is int&&.Because x+y is PRvalue expression. 

Answer 5

这个功能在你的一生中都没有出现过。自 2010 版本起，Visual Studio 就开始支持它。这是一个新的 C++11 功能，因此它不是 Visual Studio 独有的，并且是/将是可移植的。大多数编译器已经支持它。

Answer 6

auto 关键字指定将自动从其初始值设定项中扣除正在声明的变量的类型。对于函数，如果它们的返回类型是 auto，那么它将在运行时通过返回类型表达式进行计算。

当我们必须使用迭代器时它非常有用。例如，对于下面的代码，我们可以简单地使用“auto”，而不是编写整个迭代器语法。

int main() 
{ 

// Initialize set 
set<int> s; 

s.insert(1); 
s.insert(4); 
s.insert(2); 
s.insert(5); 
s.insert(3); 

// iterator pointing to 
// position where 2 is 
auto pos = s.find(3); 

// prints the set elements 
cout << "The set elements after 3 are: "; 
for (auto it = pos; it != s.end(); it++) 
    cout << *it << " "; 

return 0; 
}

这就是我们如何使用“auto”关键字

Answer 7

它不会去任何地方......它是 C++11 实现中的一个新的标准 C++ 功能。话虽这么说，虽然它是简化对象声明以及清理某些调用范式（即基于范围的 for 循环）的语法的绝佳工具，但不要过度使用/滥用它:-)

Answer 8

它的神奇之处在于它能够减少为传递到特定函数的每个变量类型编写代码的必要性。考虑在 C 语言基础上有一个与 Python 类似的 print() 函数。

#include <iostream>
#include <string>
#include <array>

using namespace std;

void print(auto arg) {
     cout<<arg<<" ";
}

int main()
{
  string f = "String";//tok assigned
  int x = 998;
  double a = 4.785;
  string b = "C++ Auto !";
//In an opt-code ASCII token stream would be iterated from tok's as:
  print(a);
  print(b);
  print(x);
  print(f);
}