1、指针常量——指针类型的常量（int *const p）

本质上一个常量，指针用来说明常量的类型，表示该常量是一个指针类型的常量。在指针常量中，指针自身的值是一个常量，不可改变，始终指向同一个地址。在定义的同时必须初始化。用法如下：

int a = 10, b = 20;
int * const p = &a;
*p = 30; // p指向的地址是一定的，但其内容可以修改

2、常量指针——指向“常量”的指针（const int *p， int const *p）

常量指针本质上是一个指针，常量表示指针指向的内容，说明该指针指向一个“常量”。在常量指针中，指针指向的内容是不可改变的，指针看起来好像指向了一个常量。用法如下：

int a = 10, b = 20;
const int *p = &a;
p = &b; // 指针可以指向其他地址，但是内容不可以改变

3、例题

（1）

int main() {
    int m = 10;
    const int n = 20; // 必须在定义的同时初始化

    const int *ptr1 = &m; // 指针指向的内容不可改变
    int * const ptr2 = &m; // 指针不可以指向其他的地方

    ptr1 = &n; // 正确
    ptr2 = &n; // 错误，ptr2不能指向其他地方

    *ptr1 = 3; // 错误，ptr1不能改变指针内容
    *ptr2 = 4; // 正确

    int *ptr3 = &n; // 错误，常量地址不能初始化普通指针吗，常量地址只能赋值给常量指针
    const int * ptr4 = &n; // 正确，常量地址初始化常量指针

    int * const ptr5; // 错误，指针常量定义时必须初始化
    ptr5 = &m; // 错误，指针常量不能在定义后赋值

    const int * const ptr6 = &m; // 指向“常量”的指针常量，具有常量指针和指针常量的特点，指针内容不能改变，也不能指向其他地方，定义同时要进行初始化
    *ptr6 = 5; // 错误，不能改变指针内容
    ptr6 = &n; // 错误，不能指向其他地方

    const int * ptr7; // 正确
    ptr7 = &m; // 正确

    int * const ptr8 = &n;
    *ptr8 = 8;

    return 0;
}

（2）判断下面程序对错，并说明理由

int main()
{
    char * const str = "apple";
    * str = "orange";
    cout << str << endl;
    getchar();
}

错误

"apple"是字符串常量放在常量区，str指向"apple"，那么str指向的是字符串常量"apple"的首地址，也就是字符a的地址，因此str指向字符a，*str就等于字符a，对*str的修改就是对字符串首字符a的修改，但"apple"是一个字符串常量，常量的值不可修改。

根据字符串赋值规则，可以修改整个字符串，方法是对指向字符串的指针str进行赋值，如下：

str = "orange";

但依旧是错误的，在该赋值语句中，系统会在常量区一块新的空间写入字符串"orange"并返回其首地址，此时str由指向字符串常量"apple"的首地址变为指向字符串常量"orange"的首地址，str指向的地址发生了变化，但str是指针常量不能被修改，所以错误。

如果想要程序编译通过，就不能将str声明为指针常量，否则str在初始化之后就无法修改。因此将const修饰符去掉，并修改字符串赋值语句，修改后程序如下：

int main()
{
    char * str = "apple";
    str = "orange";
    cout << str << endl;
    getchar();
}

参考《程序员面试笔记》

C++指针常量和常量指针

1.指针常量：int * const p=&a;

指针的指向不可以改，指向的值可以改
例如:

2.常量指针：const int *p=&a;

指针的指向可以更改，指向的值不可以更改

3.同时不可修改：const int * const p=&a;

特别地，当我们想指针的指向和指向的值都不可以修改时，可以结合上面两个，写两个const
如下图：

1.常量指针

 const int  *PtrConst 或者是 int const  *PtrConst （即const 在*的左边）
指向常量的指针，这里所说的“常量”其实在解引用时起到所谓常量的作用，并非是指向的变量就是常量，指向的变量既可以是非常量也可以是常量。总体意思是不能修改指向某变量的值。

让指针指向一个常量，可以防止使用指针来修改所指向的值。

1.常量指针指向的对象不能通过这个指针来修改，可是仍然可以通过原来的声明修改；

	int a = 1;
	const int *p = &a;
	std::cout << *p << a << std::endl;
	a = 2;//可以
	std::cout<< *p << a << std::endl;

结果
  *p = 2;
   a = 2;

如果是  *p = 3; //报错

因为不能通过这个指针来修改，所以可以用常量指针当函数的参数使用。
2.指针还可以指向别处，因为指针本身只是个变量，可以指向任意地址；

	int a = 1;
	const int *p = &a;
	std::cout << "p= "<< *p <<";" << "a=" << a << std::endl;
	int b = 2;
	p = &b;
	std::cout<<"p= "<<  *p << ";" <<"b=" <<  b<< std::endl;

p= 1;a=1
p= 2;b=2

延伸：

1.可以将const 变量的地址赋给指向const 的指针（即常量指针）。

 如 const  int  a = 1;   const int * p = &a;//可以

2.不可以将const 的地址赋给常规指针。

如 const  int  a = 1;    int * p = &a;//不可以

除非使用强制类型转换，const_cast

    const int a = 1;
    int *p = const_cast<int*>(&a)//可以

2.指针常量：

int  const  *PtrConst;
本质是一个常量，而用指针修饰它。指针常量的值是指针。

1.必须初始化，只能指向一个变量，绝不可再改变指向另一个变量

   //int *const ConstPtr;//报错，error C2734: “ConstPtr”: 如果不是外部的，则必须初始化常量对象

    int a=1;    int *const ConstPtr=&a; //可以
    int b = 2;   ConstPtr=&b;   //不可以

2.指向的地址所对应的内容可以变化。

int a=1;    int *const ConstPtr=&a;    ConstPtr = 3; //可以

如果出现在星号两边，表示被指物和指针都是常量。