指针的创建与初始化示例：

#includeusing namespace std;

//指针的创建和初始化

int main()
{float *floatPtr = NULL;
	string *strPtr;
	int *intPtr1, *intPtr2;
	int* intPtr3,  intPtr4; //intPtr4只是一个整数
       return 0 ;
}

通过示例可以看到，指针的声明就是在变量类型名和变量名之间加上星号（*），并可以并可以任意选择让星号紧贴类型名
（int * intPtr3，）或者变量名
（float *floatPtr = NULL; string *strPtr; int *intPtr1, *intPtr2;）的代码风格。然而紧贴类型名的代码风格会给人造成“int *”是一个整体的感觉，初学者很容易在声明多个指针的时候遗漏后面变量名前的星号，就像intPtr4一样，感觉像是定义了一个指针，其实只是一个整型。正确的语法是像intPtr2那样在前面加上一个星号，不管与星号之间有没有空格。

此外，示例中只有第一样的floatPtr初始化了，但是实际编程中我们一定要初始化所有指针，就跟变量一样。floatPtr的初始值NULL是一个宏定义，它的实际数值是0，也就是地址：0x00000000.一般我们都会把指针初始化为NULL，也叫做空指针，这给我们一个统一可管理的异常值。在程序中，我们只要检查指针是否为空就知道指针是否指向有效数据了。

**提示：**如果指针没有初始化，它可能指向一个未知的地址，那么我们在尝试读取数据的时候就可能造成程序崩溃。此外，在指针初始化的时候，不能使用0以外的整型给指针赋值。

除了例子中的指针类型外，c++还有一种通用的void*指针。我们知道指针就是地址，指针的类型不过表示了地址指向的位置所存储的数据类型。如果我们将int * 指针转换为float * 指针，那么程序也只是将数据重新解读为浮点类型。所以这里void * 只是代表了一个地址，而我们不知道它所指向的数据类型，但我们也可以重新定义它所指向的数据类型。void * 一般会在一些内存处理的系统函数时候使用。

对于指针来说，解引用和取地址是最重要的两个操作符。
指针的基本操作

#includeusing namespace std;

//指针的基本操作

int main()
{int num = 4 ;
	int *intPtr = #
	cout<< "num的地址是："<< &num<< endl;
	cout<< "指针的值是:"<< intPtr<< endl;
	if ( intPtr )
	{//检查指针是否为空
		cout<< "指针所指的数字是："<< *intPtr<< endl;
	}
	return 0 ;
}

运算结果：

可以看到，符号“&”表示了取地址的操作，它可以获得变量的内存地址。将其赋值给我们的指针intPtr后，打印&num和intPtr将同时获得num的地址。而当我们使用解引用操作符“ * ”的时候，* intPtr将会得到intPtr所指向的地址中的数据，也就是num的值。

在示例中，还加上了一个条件来检查指针是否为NULL，以此保证对intPtr解引用一定是安全的。这里利用了数值与布尔值之间的隐性转换，只写了intPtr作为条件，因为intPtr为空的话值会转化为false。条件intPtr也可以写成“intPtr ！= NULL”。
例子中用解引用操作符读取了指针指向的数据，而解引用操作符也可以用来作为赋值语句的左值以修改为数据。

左值解引用：

#includeusing namespace std;

//左值解引用

int main()
{int num = 4 ;
	int *intPtr = #
	if ( intPtr )
	{//检查指针是否为空
		cout<< "指针所指的数字是："<< *intPtr<< endl;
		cout<< "num的值是: "<< num<< endl;
		*intPtr = 3;
		cout<< "修改后，指针所指的数字是： "<< *intPtr<< endl;
		cout<< "num的值是："<< num<< endl;
	}
	return 0 ;
}

运行结果：

示例中，使用了左值解引用操作将指向num的指针中的数据修改为3，由于指针与num的地址相同，因此num也会变成3.指针的这一种行为可能会让初学者感到困惑，接下来我们是用图片来直观地解释指针解引用、取地址和左值解引用的行为。

指针可以像整形那样进行一部分算数操作，我还可以对地址进行修改。因为计算后的指针不一定会指向具有有效数据的地址，所以在进行指针算数操作的时候需要格外小心。

指针与整形的算数操作：

#includeusing namespace std;

//指针与整型的算数操作

int main()
{int arr[5] = {0, 1, 2, 3, 4 };
	int *ptr = arr;
	cout<< "arr + 4:"<< *(arr + 4 )<< endl;
	cout<< "ptr + 4:"<< *(ptr + 4 )<< endl;
	cout<< "ptr: "<< ptr + 2<< endl;
	cout<< "++ptr: "<< ++ptr<< endl;
	cout<< "ptr - 2: "<< ptr - 2<< endl;
	cout<< " --ptr:"<< --ptr<< endl;
	return 0;
}

运行结果：

可以看到，指针与整型的算数操作不同于一般的数字加减，而是与指针类型绑定的。由于一个int 的大小是4字节，那么ptr+2 会将地址加上8，在组中就指向第三个元素。在示例中，除了指针ptr，我们也对数组arr做了加法，得到的结果都是第五元素的值。此外，示例末尾的ox7ffd4207fe80 已经比数组的第一个元素地址还小了，如果对这个地址进行解引用，可能会使程序崩溃。

提示数组名其实可以看做是指向数组第一个元素的指针。指针的各种操作都适用于数组名但只有一点区别，那就是数组名不能被重新赋值。这样是很容易理解的，因为数组是静态的，数组名代表了当前作用域唯一的一个数组，不可能先指针那样指向其他地址。

指针除了与整型的算数操作以外，还可以进行指针相减
指针相减

#includeusing namespace std;
int main()
{int arr[5] = {0, 1, 2, 3, 4 };
	int *ptr1 = arr + 1;
	int *ptr2 = arr + 3;
	cout<< "ptr1:"<< ptr1<< endl;
	cout<< "ptr2:"<< ptr2<< endl;
	cout<< "ptr2 - ptr1: "<< ptr2 - ptr1<< endl;
	cout<< "ptr1 - ptr2: "<< ptr1 - ptr2<< endl;
	return 0 ;
}

运行结果：

指针相减返回的是指针地址之间的距离，并且是分正负的。这个距离也与类型绑定，单位是该类型数据的个数。指针之间不存在加法，每个指针代表的地址在计算机中都是唯一确定的，相加没有任何意义。这就好像是门牌号32减掉30得到2，表示他们之间，隔着两户，而32加上30却不能表示什么。

之前有使用左值解引用来修改指针指向的原变量的例子，但如果变量是const，值是不能被修改的，因此我们也需要有一种特殊的指针来保证原变量不会被修改，这就是指向const对象的指针。

指向const对象的指针

#includeusing namespace std;

//指向const对象的指针

int main()
{const int num = 3;
	//普通指针不能指向const变量
	//int *ptr1 = &num；
	const int *ptr2 = #
	cout<< "*ptr2:"<< *ptr2<< endl;
	//指向const对象的指针不能修改解引用后的值
	//*ptr2 = 4；
	//指向const对象的指针可以修改指向的地址
	const int num1 = 4;
	ptr2 = &num1;
	cout<< "*ptr2: "<< *ptr2<< endl;
	//指向const对象的指针也可以指向普通变量
	int num2 = 5;
	ptr2 = &num2;
	cout<< "*ptr2 : "<< *ptr2<< endl;
	return 0 ;
}

运行结果：

要定义一个指向const对象的指针，就要在const对象类型名后加上星号。“int* ptr1 = &num；”这一行如果去掉注释，编译器就会报错，因为普通指针不能指向const对象。“ * ptr2 =4；”这一行如果去掉注释相当于修改const对象的值，编译器也会报错。

注意虽然ptr2指向的地址不能修改，但是它本身指向的地址可以修改。示例中，我们先后又让它指向了另外两个变量，其中也有一个非const的变量，指向非const变量的这一种指针也不能修改解引用后的值。
既然指向const对象的指针还可以修改地址的，那么应该也有另外一种不能修改地址的指针，也就是const指针。

const指针

#includeusing namespace std;

//const指针

int main()
{int num1 = 3 ;
	int num2 = 4 ;
	int *const ptr1 = &num1;
	//const指针不能修改指向地址
	ptr1 = &num2 ;
	const int num3 = 5 ;
	const int num4 = 6 ;
	//指向const对象的const指针既不能修改地址，也不能修改值
	const int *const ptr2 = num3;
	ptr2 = num4;
	return 0 ;
}

示例展示了尝试修改const指针而导致的编译错误。const指针的创建语法是将const移动到了星号后面，一开始ptr1指向num1，而当我们尝试把num2的地址赋值给ptr1的时候编译器报错。一个指向const对象的const指针ptr2 ，这个指针只能指向const int变量，它指向的地址也不能改变。

标题看似是两个类似的概念，二者却截然不同。指针作为一种变量类型，当然可以被声明为数组，而数组作为一种变量类型，也可以有指向它的指针。指针的数组是一种数组，而数组的指针则是一种指针。

指针的数组和数组的指针

#includeusing namespace std;

//指针的数组和数组的指针

int main()
{int arr[5] = {0, 1, 2, 3, 4 };
	//数组的指针
	int (*arrPtr)[5] = &arr;
	//指针的数组
	int *ptrArr[5] = {&arr[0], &arr[1], &arr[2], &arr[3], &arr[4] };
	cout<< "arrPtr: "<< arrPtr<< endl;
	cout<< "*arrPtr:"<< *arrPtr<< endl;
	for (int i = 0; i< 5;i++)
	{cout<< ( *arrPtr ) [i]<< " ";
		cout<< ptrArr[i]<< " ";
		cout<< *(ptrArr[i] )<< " "<< endl;
	}
	return 0 ;
}

运行结果：

可以看到，数组的指针和指针的数组的语法区别在于：数组的指针需要在星号和变量名外面加一个括号，而指针的数组却没有。这一点其实很好理解，因为声明数组的时候元素类型名int和数组大小[5] 就是被变量名隔开的，在这里我们添加一个星号，并用括号括起来，表示这个指针int（ * arrPtr）[5]是指向整个数组的；如果不加括号，编译器就只会将星号联系到前面的类型名int，所以ptrArr就只是声明了一个数组，数组的元素类型就是int*。

在声明arrPtr的时候，我们把数组的地址赋值给他作为初值，由于数组的指针解引用以后就相当于数组，我们可以用（ * arrPtr）[i]来读取数组的元素。
ptr Arr是一个指针的数组，它的每一个元素都是一个指针，这里就将数组的每个元素的地址分别赋值，而在遍历的时候使用 * （ptrArr[i]）来读取数组中某一个指针指向的元素值。
由于这里比较不直观的一点arrPtr和*arrPtr代表的地址完全一样，为了解释这一点，再看一个示例

#includeusing namespace std;

//数组的指针的地址

int main()
{int arr1[5] = {0, 1, 2, 3, 4 };
	//数组的指针
	int (*arrPtr)[5] = &arr1;
	cout<<"arrPtr: "<< arrPtr<< endl;
	cout<<"*arrPtr:"<< *arrPtr<< endl;
	int arr2[5] = {0, 1, 2, 3, 6 };
	//数组的指针必须指向大小相同的数组
	arrPtr = &arr2;
	cout<< "arrPtr: "<< arrPtr<< endl;
	cout<< "*arrPtr:"<< *arrPtr<< endl;
	//数组的指针指向数组，而数组是不可修改的
	//*arrPtr = arr1
	return 0 ;
}

运算结果：

我们可以看到，数组的指针必须指向相同大小的数组，如果arr2只有4个元素，“ arrPtr = &arr2; ”的赋值机会产生编译错误，并且由于数组的指针指向是不可修改的数组，我们不能把arrPtr作为左值修改。

至于为什么arrPtr和 * arrPtr的地址一样，可以看做是编译器不得已的安排。数组名arr1代表着数组首元素的地址，而一般的变化量比如int1就放着一个数值，而&int1才放着int1 的地址。由于数组的这一特殊性，导致了&arr得到的数组地址与arr代表的数组地址是一样的，因此相应的arrPtr和 * arrPtr的地址也只能是一样的，* arrPtr也要搭配下标操作符才能取得数组的对应元素。

指针可以指向任何变量或者对象，所以也可以指向指针。

#includeusing namespace std;

//指针的指针

int main()
{int num = 3 ;
	int *numPtr = #
	int **numPtrPtr = &numPtr;
	cout<< "num: "<< num<< endl;
	cout<< "*numPtr: "<< *numPtr<< endl;
	cout<< "numPtr: "<< numPtr<< endl;
	cout<< "*numPtrPtr: "<< *numPtrPtr<< endl;
	cout<< "numPtrPtr: "<< numPtrPtr<< endl;
	return 0;
}

运行结果：

可以看出，指针的指针声明就多加了一个星号，以表示指针指向的指针类型，因此将numPtr的地址赋值给它。
指针的指针一般用于函数传参数时修改传入的指针。

const_cast的作用是将一个变量转换成const限定的常量。

const_cast

#includeusing namespace std;

//const_cast

int main()
{int intNum = 2 ;
	intNum = 3;
	//const_cast后面必须跟引用或指针类型
	const int &consIntNum = const_cast(intNum);
	//转换以后数字不能在修改
	//constIntNum = 2;
	return 0 ;
}

示例中，可以看到intNum在转换前是可以修改的变量，在转换以后就变成常量，不能再进行修改了。

reinterpret_cast 比较特殊。reinterpret 的意思是重新解读，而reinterpret_cast 就是将一段数据按照二进制表示重新解读成另一种数据，所以他并没有对数据做任何改变，只是改变了类型。

reinterpret_cast

#includeusing namespace std;

//reinterpret_cast

int main()
{int intNum = 0x00646362;
	int *intPtr = &intNum;
	char *str = reinterpret_cast(intPtr);
	cout<< "str的值为:"<< str<< endl;
	return 0;
}

运行结果：

在示例中，可以看到热interpret_cast将一个指向整数的指针转换成了指向字符的指针，也就是c风格的字符串，十六进制的62、63、64在ASCLL码中分别代表b、c、d，所以打印了“bcd”。
reinterpret_cast 的作用就是将一个类型的指针转换成另一个类型的指针，而指针指向的内存将被原封不动地重新解读。当然这也是一种比较危险的举动。

如果本文对您有帮助，请点赞支持一下~

你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧