c++11——auto,decltype类型推导

    auto x = 5; //被编译器推导为int类型
    auto pi = new auto(1); //编译器推导为int
    const auto* v = &x, u = 5; //v为 const int*, u为 const int
    static auto y = 0.1; //y为static const double
    auto s; //出错！ auto变量不能只声明不初始化

    int x = 0;
    auto *a = &x; //a为 int*
    auto b = &x; //b为 int*，auto可以自动识别指针类型
    auto &c = x; //c为 int&
    const auto e = x; //e为const int
    auto f = e; //f为int （非指针或引用，则不保留cv限定符）
    const auto& g = x; //g 为 const int&
    auto& h = g; //h 为 const int&(指针或引用，保留cv限定符）
    auto k = g;

void func(auto a = 1){};   //错误。auto不能用于函数参数
struct Foo{
    auto var1 = 0;      //错误，auto不能用于非晶态成员变量
    static const auto var2 = 0;
}

template<typename T>
struct Bar{};

int main(){
    int arr[10] = {0};
    auto aa = arr;  //aa被推导为int*
    auto rr[10] = arr;  //错误，auto无法定义数组
    Bar<int> bar;
    Bar<auto> bb = bar; //错误，auto无法推导出模板参数
}

    //比如stl容器
    std::map< double, double> result_map;
    std::map< double, double>::iterator it = result_map.begin();
    for(; it != result_map.end(); ++ it){};
    //通过auto可以简化为
    for (auto it = result_map.begin(); it != result_map.end(); ++it);
    std::unordered_multimap< int, int> result_map;
    std::pair< std::unordered_multimap< int, int>::iterator, std::unordered_multimap< int, int>::iterator> range = result_map.equal_range(key);
    //通过auto简化为
    auto range = result_map.equal_range(key);

class Foo{
public:
    static int get(void){
        return 0;
    }
};
class Bar{
public:
    static const char* get(){
        return "hello world";
    }
};

template<typename A>
void func(void){
    auto val = A::get();
    cout << val << endl;
}
int main(){
    func<Foo>();
    func<Bar>();
}

    int x = 0;
    decltype(x) y = 3; //y被推导为int类型
    decltype(x + y) z = 0; //z被推导为int
    const int a = 1;
    decltype(a) b = 2; //被推导为const int，尽管非指针或引用，仍然保持cv限定符
    const int& i = 9;
    decltype(i) h = x; //const int&
    decltype(z)* p = &x; //p 为int*

（1） exp是标识符，类访问表达式，decltype(exp)和exp的类型一致
（2） exp是函数调用，decltype(exp)和返回值的类型一致
（3） 其他情况，若exp是一个左值，则decltype(exp)是exp类型的左值引用，否则为和exp类型一致。

```
(1)标识符、类访问表达式，则 decltype(exp)和exp的类型一致
class Foo{
public:
    static const int Number = 0;
    int x;
};
int n = 0;
volatile const int& x = n;
decltype(n) a = n;          //int
decltype(x) b = n;          //volatile const int&
decltype(Foo::Number) c = 0;    //const int（没有static）

Foo foo;
decltype(foo.x) d = 0;  //int类型

(2) 函数调用，decltype(f(xx)) 和 函数返回值类型一致
const Foo f(){
...
}
decltype(f()) c;    //const Foo

(3) 带括号的表达式和加法运算表达式
struct Foo{
    int x;
};
const Foo foo = Foo();
decltype(foo.x) a = 0;      //a 被推导为int, 根据推导规则1
decltype((foo.x))b = a;     //b 被推导为const int&，
//因为根据foo.x 为一个左值，可知括号表达式也是一个左值。则按照推导规则3，返回左值的引用，foo为const Foo，则foo.x为一个const int类型的左值，则decltype的推导结果 为 const int&

int n = 1, m = 2;
decltype(n + m) c = 0;      //c被推导为int， n + m 为右值，则推导规则3，  
decltype(n += m) d = c;     //d被推导为int &, n += m 为左值，则推导规则3，为exp的引用
//注意此时 n 仍然为1，而不是3，因为 decltype只是推导exp的类型，而不对exp进行求值

    vector<int> v;
    ....
    decltype(v)::value_type i = 0; //知道v是一个vector，但是不知道里面的数据类型，则可以使用 decltype(v)::value_type

int& foo(int& i);
float foo(float& f);
//有如上两个函数，同名，但是返回值和参数类型不同。若想要用模板来实现两个同名函数的调用。
template<typename T>
decltype(foo(val)) func(T&val){
    return val;
}   //这样写编译不过，因为c++的返回值是前置语法，在返回值定义的时候参数变量还不存在，因此无法使用前置的decltype(foo(val)) 【需要获得decltype(foo(val))的时候，val还不存在】

但可以通过auto和decltype的自动类型推导完成。
template<typename T>
auto func(T& val) -> decltype(foo(val)) //返回值类型后置
{
    return foo(val);
}