C++11 auto和decltype推导规则

VS2015下测试：
decltype:

class Foo {};

int &func_int_r(void) { int i = 0; return i; };
int &&func_int_rr(void) { return 0; };
int func_int(void) { return 0; };

const int &func_cint_r(void) { int i = 0; return i; };
const int &&func_cint_rr(void) { return 0; };
const int func_cint(void) { return 0; };
const Foo func_cfoo(void) { return Foo(); };


int main()
{
    {
        int x = 0;
        decltype(func_int_r()) al = x;  // al -> int &
        decltype(func_int_rr()) bl = 0; // bl -> int &&
        decltype(func_int()) cl = 0;    // cl -> int


        decltype(func_cint_r()) a2 = x; // a2 -> const int &
        decltype(func_cint_rr()) b2 = 0;    // b2 -> const int &&
        decltype(func_cint()) c2 = 0;   // c2 -> int
        decltype(func_cfoo()) d2 = Foo();   // d2 -> Foo


        decltype((x)) t = x;    // t -> int &
        decltype(x + 1) t2; // t2 -> int 表达式
        decltype(++x) t3 = x;   // t3 -> int & 表达式返回左值 decltype((++x)) t4 = x; // t6 -> int &

        decltype((1)) t5 = x;   // t4 -> int
        decltype(1) t6 = x; // t5 -> int

        int i = 0;
    }

    system("pause");
    return 0;
}

• 当函数返回的是右值时，decltype会摒弃cv操作符。c2,d2
• 当标识符加上（）后，decltype结果为左值引用。t,t4
• 当表达式赋值给左值时，decltype结果为左值引用。t3
  -其它按简单推导即可。
  应用：

template<class ContainerT>
class Foo
{
    typename ContainerT::iterator it_; //类型定义可能有问题
public:
    void func(ContainerT& container)
    {
        it_ = container.begin();
    }
};



int main()
{
    typedef const vector<int> container_t;
    container_t arr;

    Foo<container_t> foo;
    foo.func(arr);

    system("pause");
    return 0;
}

编译时报错，因为当ContainerT是一个const时，it_应该是const_iterator;解决方法：

template<class ContainerT>
class Foo
{
private:
    //decltype(ContainerT().begin()) it_;//在vs2015中，ContainerT（）会被推导为vector<int>类型，const被摒弃，所以出错。
    decltype(std::declval<ContainerT>().begin()) it_;//替代方法
    static ContainerT gi;//第二种方法
    decltype(gi.begin())   it_; //不会执行表达式，只会推导，跟auto不同
public:
    void func(ContainerT& container)
    {
        decltype(ContainerT()) tt;
        it_ =container.begin();
        int i = 0;
    }
};



int main()
{
    using container_t= const vector<int> ;
    container_t arr;

    Foo<container_t> foo;
    foo.func(arr);

    system("pause");
    return 0;
}

返回类型后置语法：

template<typename U,typename R>
auto add(U u, R r)->decltype(u + r)
{
    return u + r;
}


int main()
{
    cout << add(100, 100.0f) << endl;
    cout<<add<int,float>(100, 100.0f) << endl;
    system("pause");
    return 0;
}

auto：

• 当auto后面显式添加&时，才会保留表达式cv限定符和引用。
• 当auto推导结果为指针时，保留cv操作符。
• 其它情况不保留cv限定符和引用。

int main()
{

    int x = 0;
    const auto* a = &x; // a -> const int *
    auto b = &x;    // b -> int *
    auto &c = x;    // c -> int &
    auto d = c; // d -> int
    const auto e = x;   // e -> const int
    auto f = e; // f -> int

    const auto& g = x;  // g -> const int &
    auto& h = g;    // h -> const int &
    const auto i = g;   // i -> const int
    auto j = a; // j -> const int *

    const int ci = i, &cr = ci;
    auto d1 = &i;   // d1 -> const int *
    auto e1 = &ci;  // e1 -> const int *

    system("pause");
    return 0;
}