[C++11] auto关键字详解

🍺 为什么引入auto关键字

在一些高级语言中，比如 C#、Python 等，程序员在定义变量时可以不指明具体的类型，而是让编译器（或者解释器）自己去推导，让代码的编写更加方便。
C++11为了支持自动类型推导了，引入了auto 关键字。

    auto str = "csdn"; //自动类型推断,str为 char const *
    auto fValue = 100.0;//自动类型推断,fValue为double
    auto auto_iValue = fValue;//自动类型推断,auto_iValue为double
    auto *auto_pt1 = &fValue;   //auto_pt1 为 double *
    auto  auto_pt2 = &fValue;   //auto_pt2 为 double*
    auto &auto_pt3  = fValue;   //auto_pt3 为 double
    auto auto_pt4 = auto_pt3;    //auto_pt4 为 double 

    cout << "str:"<<typeid(str).name() << endl;
    cout << "fValue:"<<typeid(fValue).name() << endl;
    cout << "auto_iValue:"<<typeid(auto_iValue).name() << endl;
    cout << "auto_pt1:"<<typeid(auto_pt1).name() << endl;
    cout << "auto_pt2:"<<typeid(auto_pt2).name() << endl;
    cout << "auto_pt3:"<<typeid(auto_pt3).name() << endl;
    cout << "auto_pt4:"<<typeid(auto_pt4).name() << endl;

输出:

当然，在真正编程的时候也不建议这样来使用auto，直接写出变量的类型更加清晰易懂。下面列举auto关键字的正确用法。

👍1.使用auto定义冗长的类型

例如迭代器，不使用auto的时候

    vector<vector<string>> vec;
    for(vector<vector<string>>::iterator i = vec.begin();i != vec.end(); i++)
    {
        /**/
    }

使用auto会变得更加简洁

    vector<vector<string>> vec;
    for(auto i = vec.begin();i != vec.end(); i++)
    {
        /**/
    }

auto 可以根据表达式vec.begin()函数的返回值类型来推导出变量 i 的类型。

👍2.auto 用于泛型编程

🔥模板函数中声明依赖模板参数的变量类型

在定义模板函数时，用于声明依赖模板参数的变量类型。

template <typename _Tx,typename _Ty>
void add(_Tx x, _Ty y)
{
    auto sum = x+y;
    cout << "sum:"<<typeid(sum).name() << endl;
    std::cout << sum;
}

如果不使用auto关键字，需要额外增加一个模板参数，并在调用时手动给该模板参数赋值，用以指明变量 sum 的类型。

template <typename _TR, typename _Tx,typename _Ty>
void add(_Tx x, _Ty y)
{
    _TR sum = x+y;
    cout << "sum:"<<typeid(sum).name() << endl;
    std::cout << sum;
}

🔥模板函数返回值依赖模板参数的变量类型

这里用到了decltype关键字，也是C++11标准引入的新的运算符。auto在这里的作用只是为函数返回值占了一个位置，真正的返回值是后面的decltype(x+y)。

template <typename _Tx, typename _Ty>
auto add(_Tx x, _Ty y)->decltype(x+y)
{
    return x+y;
}

这里使用了返回尾置法，为什么需要尾置呢，如果这样写

template <typename _Tx, typename _Ty>
decltype(x+y) add(_Tx x, _Ty y)
{
    return x+y;
}

编译器将会报错，因为编译器是从左往右，从上到下读取代码的，所有x+y的类型还不确定。

如果不用auto关键字，写法将会非常复杂，先用0，转为模板参数类型指针，再取指针。

template <typename _Tx, typename _Ty>
decltype(*(_Tx*)(0) + *(_Ty*)(0)) add(_Tx x, _Ty y)
{
    return x+y;
}

当然，c++14以后，可以直接这样写

template <typename _Tx, typename _Ty>
auto add(_Tx x, _Ty y)
{
    return x+y;
}

👍3.auto配合lambda

使用auto推断lambda类型

    auto fun = [](int x, int y){return x + y;};
    auto v = fun(1,2);

如果不使用auto,则需要使用std::function来存储

    std::function<int(int,int)> fun = [](int x, int y){return x + y;};
    auto v = fun(1,2);

👑使用auto关键字注意事项

1.auto不能用于函数的参数。因为auto 必须对变量进行初始化，而函数的形参只有在实际调用函数的时候才会给参数赋值。
然而，c++14之后，lambda允许，函数参数类型为auto类型,如

auto r = [](auto x, auto y){return x + y;};

2.auto 不能作用于类的非静态成员变量（也就是没有 static 关键字修饰的成员变量）。
3.auto 不能用于模板参数