指向指针的引用
引用本身不是一个对象，所以不能定义指向引用的指针，但指针是对象，所以存在指针的引用。
可以通过从右往左理解为什么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");
}
