第2课 类型推导（2）_decltype关键字

#include <iostream>
using namespace std;

int main()
{
    int x = 0;
    
    decltype(x) y = 1;      //y: int
    decltype(x + y) z = 0;  //z: int
    
    const int& i = x;
    decltype(i) j = y;   //j: const int&，保留cv和引用属性
    
    const decltype(z)* p = &z; //p: const int*，
                               //decltype(z)*在z的类型基础上加个*
    
    //const auto* p = &z;   //p: const int*,此处auto*中的*是冗余的
                            //相当于const auto p = &z;
                            
    decltype(z)*  pi = &z; //pi: int*
    decltype(pi)* pp = &pi; //在pi类型的基础上加个*，即pp:int**
    
    return 0;
}

#include <iostream>

using namespace std;

const int g_ci = 0;
const int& g_ri = g_ci;

const int foo(int){
    return 0;
}

const int bar(int){
    return 0;
}

class test
{
public:
    test& operator=(const test& rhs)
    {
        var1 = rhs.var1;
        return *this;
    }
    const double foo(int){return 0;}
    const double bar(int){return 0;}
    
    int var1 = 0;
    
    const double var2 = 0;
    static const int n = 0;
};

int arr[10];
int&& g_rr=0;  //g_rr: int&&(纯右值)
int* ptr = arr;

test t;

const int& foo2(int){
    static int kk;
    return kk;
}

const test testfunc(){
    //return test();
}

int main()
{
    //////////////////////////////////////////////////////////////////////////////////////
    //规则1：简单标记符表达式和类成员表达式
    decltype(g_ci) ci = 0;  //ci: const int;
    decltype(g_ri) ri = ci;  //ri: const int&;
    decltype(arr)  ar = {1,2,3,4,5}; //ar: int[5]
    
    decltype(foo)* pfbar = bar;  //pfbar：const int (*)(int)，函数指针
    decltype(&foo) pfbar2 = bar; //pfbar2类型与pfbar相同
    
    decltype(test::foo) ptestbar = test::bar; //pftestbar: const double (test::*)(int);
    (t.*ptestbar)(123);//函数调用
    decltype(&test::foo) ptestbar2 = &test::bar; //pftestbar2类型与pftestbar相同
    (t.*ptestbar2)(123);//函数调用
    
    decltype(test::var1) tvar1 = 0; //tvar1: int
    decltype(t.var1)  tv1 = 0;   //tv1: int 
    decltype(&test::var1) ptv1 =&test::var1; //ptv1: int test::*,可t.*ptv1=2方式来访问。
    
    decltype(test::var2) tvar2 = 0.0; //tvar2: const double
    decltype(t.var2) tv2 = 0.0;  //tv2: const double;
    decltype(&test::var2) ptv2 =&test::var2; //ptv2: const double test::*
    
    decltype(t.n) tn = 0; //tn: const int;
    
    //////////////////////////////////////////////////////////////////////////////////////
    //规则2：lvalue,xvalue,pvalue表达式规则
    //如果一个表达式不是“简单id-expression”，则e必是三者之一.
    //IF e ==> lvalue  THEN decltype(e) ==> T&
    //IF e ==> prvalue THEN decltype(e) ==> T  //重要提示：e为普通类型时，推导结果cv丢失。e为类类型时则保留cv
    //IF e ==> xvalue  THEN decltype(e) ==> T&&
    
    //函数调用，取返回值类型
    decltype(foo(123)) foo1 = 0; //foo1: int，函数调用，返回值为纯右值，cv被丢弃。
    foo1 = 1; //编译通过，证明foo1的const属性被丢弃
    
    decltype(t.foo(123)) tfoo = 0.0; //tfoo: double，返回值为pvalue，cv丢失。
    
    decltype(foo2(123)) lfoo = 0;    //lfoo: const int&, 返回值是左值，cv保留
    //lfoo = 2; //编译不通过，因为lfoo具有const属性。
    
    int i=0;
    int& j=i;
    decltype(++i) i1 = j; //i1: int&，即左值引用，因为++i结果是左值。
    decltype(i++) i2 = 0; //i2: int,即纯右值，因为i++结果是纯右值。
    
    decltype(++j) j1 = i; //j1: int&
    decltype(j++) j2 = 0; //j2: int
        
    decltype(std::move(i)) i3 = 0; //i3：int&&。因为i被move为xvalue。
    
    int m=0,n=0;
    decltype(m+n) mn = 0; //mn: int
    decltype(n +=m) mn2 = m;//mn2: int&。因为n+=m的结果是左值。
    
    decltype(arr[3]) ar3 = m; //ar3: int&，因为arr[3]可以被赋值，是个左值
    decltype(*ptr) ptri = m;  //ptri: int&，因为*ptr可以被赋值，是个左值。
    
    decltype("string") str = "string"; //str: const char(&)[7],因为字符串字面量为左值。
    
    //////////////////////////////////////////////////////////////////////////////////////
    //规则3：带括号表达式规则
    decltype((i)) i4 = j; //i4: int&。因为，i是个表达式，(i)也是个(左值)表达式。
    decltype((foo(123))) foo3 = 0; //foo3: int。因为foo函数的返回值为const int类型，加括号后表达式类型
                                   //仍为const int类型，是一个prvalue。故推导结果为int
    foo3 = 1;                      //编译通过，表示foo3丢弃了const属性
    decltype((testfunc())) tfunc;  //tfunc: const test，因为testfunc函数返回值为const test类型，是一个prvalue。
                                   //加括号后的表达式仍为prvalue，但由于是类类型，故要保留const属性。
    
    cout <<is_const<decltype(tfunc)>::value<<endl; //输出1，表示tfunc丢失了const属性。
    
    //decltype((t.var1)) tv; //tv: int&。因为t.var1是个左值。推导结果为左值引用，即int&。但该行会产生编译错误，
                             //因为声明引用的同时，必须初始化
    cout <<is_lvalue_reference<decltype((t.var1))>::value<<endl; //输出1，是一个左值引用
    
    return 0;
}

#include <iostream>
using namespace std;

const int ci = 0;
volatile int vi;

struct S
{
    int i;
};

const S a = {0};

volatile S b;
volatile S* p = &b;

int main()
{
    ///////////////////////////////////////////////////////////
    //const对象，使用decltype进行推导时，其成员不会继承const或volatile限定符
    //普通对象
    cout << is_const<decltype(ci)>::value << endl;    //1，是const对象
    cout << is_volatile<decltype(vi)>::value << endl; //1, 具有volatile属性
    
    //类对象
    cout << is_const<decltype(a)>::value << endl;    //1，是const对象
    cout << is_volatile<decltype(b)>::value << endl; //1, 具有volatile属性

    cout << is_const<decltype(a.i)>::value << endl;    //0，const属性不会继承给成员变量
    cout << is_volatile<decltype(p->i)>::value << endl; //0, volatile属性不会继承给成员变量    
    
    //cv限定符的冗余：通常情况下，如果推导出的类型己经有cv属性，则冗余的符号会被忽略。
    //注意，auto一般会丢弃cv，而decltype一般会保留cv。
    int i = 1;
    int& j = i;
    int* p = &i;
    const int k = 1;
    
    decltype(i)& var1 = i;  //var1: int&
    decltype(j)& var2 = i;  //var2: int&。j中多出一个&，则冗余的&被忽略
    cout << is_rvalue_reference<decltype(var2)>::value << endl;//0，var2不是右值引用，即不是int&&
    cout << is_lvalue_reference<decltype(var2)>::value << endl;//1，var2是左值引用，即int&
    
    //decltype(p)* var3 = &i; //var3：int**，与&i类型不匹配，编译不通过。
    decltype(p)* var3 = &pl;  //var3: int**。注意，decltype(p)*中的*不是冗余的！！！
    
    auto* v3 = p;  //v3: int*。注意auto*中的*是冗余的，相当于auto v3 = p;
    
    const decltype(k) var4 = 1; //var4: const int; 因为decltype(k)推导出来己带const，
                                //所以最前面的const是冗余的。
    
    
    return 0;
}