C++；自动关键字。为什么是魔法？ 从我以前学习C++的所有材料中，自动AUT/COME >一直是一个奇怪的存储持续时间说明符，没有任何用途。但就在最近，我遇到了将其本身用作类型名的代码。出于好奇，我尝试了它，它采用了我分配给它的任何类型

突然间，STL迭代器和任何使用模板的东西都比编写容易10倍。感觉就像我在使用一种“有趣”的语言，比如Python

---

这个关键词在我的一生中都在哪里？你会说它是VisualStudio独有的还是不可移植的，让我的梦想破灭吗？

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

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

< P>它不会去任何地方…它是C++ 11实现的一个新的标准C++。也就是说，虽然它是简化对象声明以及清理某些调用范式的语法的极好工具（即基于循环的范围），但不要过度使用/滥用它：-（<

P>>代码> Auto <代码> >是C++从C继承的关键字，它几乎已经存在，但实际上从未使用过，因为只有两个可能的条件：要么不允许，要么默认假设

在C++11中，使用

auto

表示推导的类型是新的

同时，

auto x=initializer

从

initializer

的类型推断出

x

的类型，与模板类型推断对函数模板的作用相同。考虑这样的函数模板：

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

模板
int（T）{
//A点
};

在点A处，已根据传递给

which

的参数值将类型分配给

T

。当您执行

auto x=初始值设定项时

，相同的类型推断用于根据用于初始化它的

初始值设定项的类型来确定
x
的类型

这意味着编译器实现
auto
所需的大多数类型推断机制已经存在，并用于任何编译器上的模板，这些编译器甚至试图实现C++98/03。因此，添加对
auto
的支持对于基本上所有的编译器团队来说都是相当容易的——它添加得相当快，而且似乎也很少有与之相关的bug

当这个答案最初被写入（2011，在C++ 11标准上的墨水干燥之前）<代码> Audio/Cord>已经相当便携了。如今，它在所有主流编译器中都是完全可移植的。避免这种情况的唯一明显原因是，如果您需要编写与C编译器兼容的代码，或者您特别需要针对某些您知道不支持它的小型编译器（例如，一些人仍然使用Borland、Watcom等的编译器为MS-DOS编写代码，这些编译器几十年来都没有出现重大升级）。如果您使用的是任何主流编译器的合理最新版本，那么根本没有理由避免它。
对于变量，指定将从其初始值设定项自动推断要声明的变量类型。对于函数，指定返回类型为尾随返回类型，或将从其返回语句（自C++14以来）推导出返回类型

语法
解释
在块范围、命名空间范围、for循环的初始化语句等中声明变量时，关键字auto可以用作类型说明符

一旦确定了初始值设定项的类型，编译器将使用函数调用中模板参数推断的规则确定将替换关键字auto的类型（有关详细信息，请参阅模板参数推断#其他上下文）。关键字auto可能伴随着修饰符，例如const或&，它们将参与类型推断。例如，给定
const auto&i=exprf（expr）
，则i的类型正是虚模板
模板void f（const u&u）
中参数u的类型。因此，根据在基于范围的for循环中使用的初始值设定项，可以将auto&&推断为左值引用或右值引用

如果使用auto声明多个变量，则推导的类型必须匹配。例如，声明
autoi=0，d=0.0格式错误，而声明
auto i=0，*p=&i格式正确，自动值推断为int


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


在不使用尾部返回类型语法的函数声明中，关键字auto表示将使用模板参数推断规则从其返回语句的操作数推断返回类型


如果变量的声明类型是
decltype（auto）
，则关键字auto将替换为其初始值设定项的表达式（或表达式列表），并使用decltype规则推断实际类型


如果函数的返回类型声明为
decltype（auto）
，则关键字auto将替换为其返回语句的操作数，并使用decltype规则推断实际返回类型


形式为auto:：的嵌套名称说明符是占位符，由遵循约束规则的类或枚举类型替换
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)

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; 
}

#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);
}

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.

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&& 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.