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");
}