C++类型处理

指向指针的引用

引用本身不是一个对象，所以不能定义指向引用的指针，但指针是对象，所以存在指针的引用。
可以通过从右往左理解为什么p是一个指针的引用，p的左边是引用符号，因此p是一个引用，其余部分表示p引用的是一个int指针。

int main()
{
    int value1 = 10;
    int *value2 = &value1;
    int *&p = value2;
    *p = 100;
    std::cout << value1 << std::endl;//100
    return 0;
}

顶层const和底层const

顶层const表示指针本身是一个常量，底层const表示指向的对象是一个常量。

int main(void)
{
    int value1 = 10;
    const int *value2 = &value1;//指向const int的指针 底层const
    int* const value3 = &value1;//指向int的常量指针 顶层const

    *value2 = 100;//错误，指针指向的是一个常量，const int
    value2 = nullptr;//正确，指针本身可以修改

    *value3 = 100;//正确，指针指向的是int
    value3 = nullptr;//错误，指针本身是常量
    return 0;
}

类型别名

有两种方式可以定义类型别名typedef和using。

typedef int xyint;//xyint是int的类型别名
typedef int *pxyint;//pxyint是int*的类型别名
using xydouble = double;//xydouble是double的类型别名
using pxydouble = double*;//pxydouble是double*的类型别名

int main(void)
{
    xyint value1 = 0;
    xydouble value2 = 3.14;
    pxyint value3 = nullptr;
    pxydouble value4 = nullptr;
    return 0;
}

它们之间的区别是typedef不能为模板类设置类型别名。

template <typename T>
typedef std::vector<T> vType;//错误


template <typename T>
using vType = std::vector<T>;//正确

类型别名，const，指针

如果类型别名指代的是指针类型，然后用const修饰的时候会产生意想不到的后果，例如下面的const pxyint，实际上指的是指向一个int的常量指针，原因是类型别名不是直接替换的，这个时候应该把pxyint看做一个整体。

typedef int *pxyint;
using pxydouble = double*;

int main(void)
{
    double value1 = 3.14;
    int value2 = 10;

    const pxyint value3 = &value2;//指向int的常量指针 顶层const
    const pxydouble value4 = &value1;//指向double的常量指针 顶层const
    *value3 = 100;//正确
     value3 = nullptr;//错误

    *value4 = 100;//正确
    value4  = nullptr;//错误
    return 0;
}

pxyint如果是用#define定义的话，const pxyint就是一个底层const了。

#define pxyint int * 

int main(void)
{
    int value1 = 10;
    const pxyint value2 = &value1;//指向const int的指针 底层const

    *value2 = 100;//错误
     value2 = nullptr;//正确
    return 0;
}

auto

有时候根本不知道一个表达式的类型，或者很难做到，C++11引入了auto类型说明符，让编译器自动去分析表达式的类型，所以auto定义的变量必须要有一个初始值。

int main(void)
{
    int value1 = 10;
    auto value2 = value1 + 100;//value2被推断为int
    return 0;
}

和类型别名一样，auto类型为指针类型时用const修饰会得到一个顶层const，而不是底层const。

int main(void)
{
    int value1 = 0,*value2=&value1;
    const auto value3 = value2;//顶层const
    *value3 = 100;//正确
    value3 = nullptr;//错误
    return 0;
}

使用auto定义多个变量时，类型必须一样。

int main(void)
{
    auto value1 = 0, *value2 = &value1;//正确，value1是整形，value2是整形指针
    auto value3 = 0, value4 = 3.14;//错误，value3和value4类型不匹配
    return 0;
}

引用类型作为初始值时，auto推断出来的类型为引用对象的类型，如果希望推断出来的是一个引用，需要明确指出。

int main(void)
{
    int value1 = 0, &value2 = value1;
    auto value3 = value2;//value3类型为int
    auto &value4 = value1;//value4为一个引用
    return 0;
}

auto会忽略顶层const，保留底层const，如果希望推断出来的是一个顶层const，需要明确指出。

int main(void)
{
    const int value1 = 0;
    auto value2 = value1;//value2是int类型
    const auto value3 = value1;//value3是const int类型
    return 0;
}

设置一个类型为auto的引用时，初始值中的顶层const将会保留。

int main(void)
{
    const int value1 = 0;
    auto &value2 = value1;//value2为const int
    return 0;
}

decltype

有时候我们想使用表达式推断出来的类型，但是不想调用这个表达式，C++11引入了decltype类型指示符满足这一要求，它的作用是返回表达式的数据类型，但是不会调用这个表达式。

int main(void)
{
    int value1 = 0;
    decltype(value1) value2 = 100;//value2类型为int
    return 0;
}

和auto不一样， decltype不会忽略表达式的顶层const和引用。

int main(void)
{
    const int value1 = 0;
    const int &value2 = value1;
    decltype(value1) value3 = 100;//value3类型为const int
    decltype(value2) value4 = value1;//value4为const int的引用
    return 0;
}

如果decltype表达式内容是指针的解引用操作，那么结果会是一个引用。

int main(void)
{
    int *value1 = nullptr;
    decltype(value1) value2;//value2是一个指针
    decltype(*value1) value3;//value3是int的引用
    return 0;
}

decltype表达式如果是双层括号，那么结果永远是引用，必须初始化。

int main(void)
{
    int value1 = 0;
    decltype((value1)) value2;
    return 0;
}

我们还可以利用标准类型转换模板从一个引用获取非引用类型。

int main()
{
    int value1 = 0;
    int& value2 = value1;
    remove_reference<decltype((value2))>::type value3=100;
    cout <<value3<< endl;
    system("pause");
}