New feature of C11 - Auto and decltype type type indicators

1、auto Type specifier

（1）auto Is to let the compiler calculate the type of variable through the initial value , therefore auto A defined variable must have an initial value .
（2）auto You can declare multiple variables in one statement , The initial basic data type of multiple edges must be the same .
（3）auto Will ignore the top const, Keep the underlying const.
for example ：

int i=0;

const int a=i;
auto b=a;// there b It's a int type ,a The top floor of const Features are ignored 

auto c=&a;// there c Is a pointer to an integer constant , Therefore, the underlying const.( Addressing a constant object is a kind of bottom layer const)

(4) Set a type to auto references , The top level constant property in the initial value remains .
for example :

auto &d=a;//d Is a reference to an integer constant 

2、decltype Type indicator

（1）decltype The type of variable to be defined can be inferred from the type of expression , So it is not necessary to initialize the variable with the value of the expression .
for example ： The compiler does not need to call a function , Instead, you can determine the type of variable to be defined by the return type of the function .
（2） If decltype The expression used is a variable , be decltype Returns the type of the variable （ Including the top floor const And quote in ）.
for example ：

const int a=0,&b=a;

decltype(a) x = 0;//x The type is const int
decltype(b) y = x;//y The type is const int& 

（3）decltype And references ：
① If decltype The expression used is not a variable , that decltype Return the type corresponding to the expression result .
② If the content of an expression is a dereference operation , be decltype The result is a reference type .
as a result of ： Dereference the pointer to get the object pointed to by the pointer , And you can assign values to this object , therefore decltype(*p) The result is int&, Instead of int.
for example ：

int i=1,*p=&i,&r=i;

decltype(r+1) b;//b Is uninitialized int type 
decltype(*p) c;//c yes int&, Must be initialized 

③decltype If the expression is a variable with parentheses , The result will be to quote .
as a result of ： Add brackets , The compiler will treat it as an expression , A variable is a special expression that can be used as an lvalue of an assignment statement , therefore In this way decltype You'll get the reference type .
for example ：

decltype((i)) d;// Compilation error , because d yes int&, Must be initialized 
decltype(i) e;//e Is an uninitialized int