常指针与指针常量的区别？

常量指针和指针常量有什么区别~

区别：
1、本质
指针常量：本质上一个常量，指针用来说明常量的类型，表示该常量是一个指针类型的常量。
常量指针：本质上是一个指针，常量表示指针指向的内容，说明该指针指向一个“常量”。
2、地址
指针常量：在指针常量中，指针自身的值是一个常量，不可改变，始终指向同一个地址。在定义的同时必须初始化。
常量指针：指针可以指向其他地址
3、内容
指针常量：指向的内容可以修改
常量指针：在常量指针中，指针指向的内容是不可改变的，指针看起来好像指向了一个常量。

扩展资料
指针是一个特殊的变量，它里面存储的数值被解释成为内存里的一个地址。要搞清一个指针需要搞清指针的四方面的内容：指针的类型、指针所指向的类型、指针的值或者叫指针所指向的内存区、指针本身所占据的内存区。
从语法的角度看，你只要把指针声明语句里的指针名字去掉，剩下的部分就是这个指针的类型。这是指针本身所具有的类型。
当你通过指针来访问指针所指向的内存区时，指针所指向的类型决定了编译器将把那片内存区里的内容当做什么来看待。
从语法上看，你只须把指针声明语句中的指针名字和名字左边的指针声明符*去掉，剩下的就是指针所指向的类型。
指针的值是指针本身存储的数值，这个值将被编译器当作一个地址，而不是一个一般的数值。在32 位程序里，所有类型的指针的值都是一个32 位整数，因为32 位程序里内存地址全都是32 位长。指针所指向的内存区就是从指针的值所代表的那个内存地址开始，长度为si zeof(指针所指向的类型)的一片内存区。
在32 位平台里，指针本身占据了4 个字节的长度。指针本身占据的内存这个概念在判断一个指针表达式（后面会解释）是否是左值时很有用。
参考资料：百度百科 - 指针

常量指针是指--指向常量的指针，顾名思义，就是指针指向的是常量，即，它不能指向变量，它指向的内容不能被改变，不能通过指针来修改它指向的内容，但是指针自身不是常量，它自身的值可以改变，从而可以指向另一个常量。
指针常量是指--指针本身是常量。它指向的地址是不可改变的，但地址里的内容可以通过指针改变。它指向的地址将伴其一生，直到生命周期结束。有一点需要注意的是，指针常量在定义时必须同时赋初值。

2.使用方法
写法上的区别：
常量指针：const 在*之前 指针常量：const在*之后。
使用举例：
（1） 常量指针使用：
如 int b, c;
int const *a;
a = &b;
a = &c;
都可以，唯独它指向的内容不能被修改。如：*a=20;这是违法的！错误！
（2） 指针常量使用
如 int a ,b;
int * const p = &a;
表示p是一个常量指针它指向变量a的内存。指针常量不能再用p指向其他变量，如 p = &b; 错误！可以修改指向内存的值，如:* p = 20; 指针常量声明的时候必须像上式那样赋初值。
指针常量也不能释放,用p指向NULL，即
p = NULL;
会在编译时报错
/opt/test/test.c:649: error: assignment of read-only variable `p'
还有一个记住他们不同形式的技巧！看const关键字，他后面的不可修改，如int * const a = &b; 后面是a,则说明a不能修改！
int const * a = &b;后面是*a则说明*a不可被修改！

1 常量指针！如 int b, c; int * const a = &b;
表示a是一个常量指针它指向变量b的内存。但是因为是常量指针所以不能再用a指向其他变量，如 a = &c; 错误！可以修改指向内存的值，如:*a = 20; BTW 常量指针声明的时候必须向我那样赋初值。

2 指向常量的指针！如 int b, c; int const *a; a = &b; a = &c;
都可以，唯独它指向的内存不能被修改。如：*a=20;这是违法的！错误！

这就是主要区别！

BTW 还有一个记住他们不同形式的技巧！看const关键字，他后面的不可修改，如int * const a = &b; 后面是a,则说明a不能修改！
int const * a = &b;后面是*a则说明*a不可被修改！

在好多书上或MSDN是经常用 const int a=5;
int b=6;
const int *p=&b;
其实 const int* 和int const* 一样，就是常指针 也就是它所指向的数据（在这是int）是常量，它自己的数据类型是const int*
还有const int *p=&b;是可以的 虽然b不是常量。
但是 const int a=6;
int *p=&a;
会报错，因为它消除了a的const属性
**********************************************

*******我们可以总结一下********
1. 对于常量（符号常量）和常指针、常引用常对象声明都是一样的
定义格式： const 数据类型 常量名=常量值；
或 数据类型 const 常量名=常量值；

例如：const int a=7; 或 int const a=7;（符号常量）
int b=5;
const int *p=&b; 或 int const *p=&b;(常指针）
const int &m=b;（常引用）
const Point pt; 或 Point const pt; //常对象不能更新
常指针和常引用在功能上有所限制，就是不能通过他们更改其指向的变量的数据（值）

2. 指针常量
定义格式： 数据类型 *const 指针常量=常量值；
如char ch,*const pch=&ch;(我是一步完成的，你也可以分开）
也就是说这个指针本身是个常量，不可改变，即它所指向的地址是固定的。但，ch是可以改变的。

************************************

下面是MSDN中关也常对象的说法
///////////////////////////////////
Initializing Pointers to const Objects
A pointer to a const object can be initialized with a pointer to an object that is not const, but not vice versa. For example, the following initialization is legal:

Window StandardWindow;
const Window* pStandardWindow( &StandardWindow );

In the preceding code, the pointer pStandardWindow is declared as a pointer to a const object. Although StandardWindow is not declared as const, the declaration is acceptable because it does not allow an object not declared as const access to a const object. The reverse of this is as follows:

const Window StandardWindow;
Window* pStandardWindow( &StandardWindow );

The preceding code explicitly declares StandardWindow as a const object. Initializing the nonconstant pointer pStandardWindow with the address of StandardWindow generates an error because it allows access to the const object through the pointer. That is, it allows removal of the const attribute from the object.
///////////////////////////////////////

有问题我们再到HiKe电脑吧讨论！
来源：http://hike.bokee.com/6169539.html

---

西秀区13249642020： 常指针与指针常量的区别? - ？
长元镇咳： 1 常量指针!如 int b, c; int * const a = &b; 表示a是一个常量指针它指向变量b的内存.但是因为是常量指针所以不能再用a指向其他变量,如 a = &c; 错误!可以修改指向内存的值,如:*a = 20; BTW 常量指针声明的时候必须向我那样赋初值....

西秀区13249642020： 常指针和指向常量的指针的区别 - ？
长元镇咳： const char *p; 常量指针,指向一块区域,这块区域不可写,只能读.char * const p; 指针常量,指向一块区域,这块区域可读可写,但是指针的值初始后就不能改,类似于一般常量.const char * const p; 上面两种类型的综合,指针指向的区域不可写,可读.指针初始化后不能改.至于有什么用,看具体要求.比如char * stpcpy(char *s1, const char *s2) 这个函数,把常量指针s2指向的字符串copy到s1中,const 修饰符表明这个函数不会也不能对s2指向的字符串作任何修改.

西秀区13249642020： 指针常量和常量指针的区别 - ？
长元镇咳： int a = 10; int * b = a;//指针 const int * c = a;//指向常量的指针 int * const d = a;//常量指针 const int * const * e = a;//常量指向常量的指针 你想问什么 b是可以修改自己,就是可以重新指向别人,也可以修改a的数据 c是不能修改a的数据,不过可以重新指向别人 d是不能重新指向别人不过可以修改a的数据 e是既不能指向别人也不能修改a的数据

西秀区13249642020： 常量指针与指针常量的区别 - ？
长元镇咳： 常量指针是指--指向常量的指针,顾名思义,就是指针指向的是常量,即,它不能指向变量,它指向的内容不能被改变,不能通过指针来修改它指向的内容,但是指针自身不是常量,它自身的值可以改变,从而可以指向另一个常量. 指针常量是...

西秀区13249642020： 常量指针和指针常量有什么区别 - ？
长元镇咳：[答案] int a;int * const p = &a //指针常量,*p可以修改*p = 8;(OK)p不可以修改 p++(ERROR)int a,b;const int *p = &a;//常量指针 *p不可修改 *p = 8;(ERROR)p 可以修改 p = &b (OK)还有一种const int * cons...

西秀区13249642020： “指向常量的指针”“常指针”“指向常量的常指针”该如何区分理解呢?(详细)谢谢了,大神帮忙啊 - ？
长元镇咳： 常指针即常量指针 1 常量指针!如 int b, c; int * const a = &b; 表示a是一个常量指针它指向变量b的内存.但是因为是常量指针所以不能再用a指向其他变量,如 a = &c; 错误!可以修改指向内存的值,如:*a = 20; BTW 常量指针声明的时候必须向我那样赋初值. 2 指向常量的指针!如 int b, c; int const *a; a = &b; a = &c; 都可以,唯独它指向的内存不能被修改.如:*a=20;这是违法的!错误! 3 指向常量的常指针 如int const * const a 求采纳

西秀区13249642020： 指针常量和常指针的区别? - ？
长元镇咳： int a;int * const p = &a //指针常量,*p可以修改*p = 8;(OK) p不可以修改 p++(ERROR) int a,b;const int *p = &a;//常量指针 *p不可修改 *p = 8;(ERROR) p 可以修改 p = &b (OK) 还有一种 const int * const p = &a; // *p 和 p均不可改变了

西秀区13249642020： C++中,常量指针和指针常量的区别如何记忆? - ？
长元镇咳： 常量指针 是指向常量的指针.表示指针本身值可以改,但指向值不可以改.即p的值可以变,但是*p不能变 形式是 const TYPE *p; 或者 TYPE const *p; 指针常量 是说指针本身是常量. 也就是p不可以改,但是*p是可以改的.形式是 TYPE * const p; 复合起来 就是常量指针常量... 绕口吧,就是这样 定义 const TYPE * const p; p和*p都不能改.

西秀区13249642020： 常量指针和指针常量有什么区别 - ？
长元镇咳： int a;int * const p = &a //指针常量,*p可以修改*p = 8;(OK) p不可以修改 p++(ERROR) int a,b;const int *p = &a;//常量指针 *p不可修改 *p = 8;(ERROR) p 可以修改 p = &b (OK) 还有一种 const int * const p = &a; // *p 和 p均不可改变了

西秀区13249642020： 指针常量和常量指针的区别如何记忆? - ？
长元镇咳： 看const在哪里:数据类型 * 指针变量名; 这个声明格式 指针变量名前面有3个空白可以加入const 前面两个都是修饰的指针,都是指向常量的指针,比如int const *p; 或者const int *p;自己可以变,但是不能通过这个指针来改变指针指向的目标 最后一个,const 距离变量名最近,因此指针是常量,自己不能改变了,但是可以通过这个指针改变指针指向的目标