这种功能并不是你一生中就有的。自2010年版本以来，Visual Studio一直支持它。它是c++ 11的一个新特性，所以它不是Visual Studio独有的，并且是可移植的。大多数编译器已经支持它了。

auto关键字是c++中一个重要且常用的关键字。在初始化变量时，auto关键字用于类型推断(也称为类型推断)。

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

第一条规则

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

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. 

这种功能并不是你一生中就有的。自2010年版本以来，Visual Studio一直支持它。它是c++ 11的一个新特性，所以它不是Visual Studio独有的，并且是可移植的。大多数编译器已经支持它了。

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

使用auto来表示演绎的类型是c++ 11中新出现的。

同时，auto x = initializer从初始化式的类型中推断x的类型，这与模板类型推断函数模板的工作方式相同。考虑这样一个函数模板:

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

在点A，一个类型已经根据传递给参数的值赋给了T。当您执行auto x = initializer;时，将使用相同的类型推断，从用于初始化x的初始化式的类型中确定x的类型。

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

When this answer was originally written (in 2011, before the ink was dry on the C++ 11 standard) auto was already quite portable. Nowadays, it's thoroughly portable among all the mainstream compilers. The only obvious reasons to avoid it would be if you need to write code that's compatible with a C compiler, or you have a specific need to target some niche compiler that you know doesn't support it (e.g., a few people still write code for MS-DOS using compilers from Borland, Watcom, etc., that haven't seen significant upgrades in decades). If you're using a reasonably current version of any of the mainstream compilers, there's no reason to avoid it at all though.

该标准最近的修订增加了一些可以使用auto的新地方。从c++ 14开始，你可以使用auto作为lambda的形参类型:

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

这在本质上与上面的示例所做的事情相同——尽管它没有显式地使用模板语法，但这基本上是一个推断形参类型的模板，并根据该类型实例化模板。

这是非常方便和有用的，以至于在c++ 20中，为普通函数添加了相同的功能，而不仅仅是lambdas。

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

它不会去任何地方……它是c++ 11实现中的一个新的标准c++特性。也就是说，虽然它是一个简化对象声明以及清理某些调用范式(即基于范围的for循环)语法的好工具，但不要过度使用/滥用它:-)

它的神奇之处在于它能够减少为传递到特定函数的每个变量类型编写代码。考虑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);
}