C 常量指针与常量值上的指针

以下声明之间有什么区别

char * const a;
const char * a;

为了理解其中的差异，我编写了这个小程序：

#include <stdio.h>
#include <stdlib.h>


int main (int argc, char **argv)
{
    char a = 'x';
    char b = 'y';

    char * const pc1 = &a;
    const char * pc2 = &a;

    printf ("Before\n");
    printf ("pc1=%p\n", pc1);
    printf ("*pc1=%c\n", *pc1);
    printf ("pc2=%p\n", pc2);
    printf ("*pc2=%c\n", *pc2);

    *pc1 = b;
/*     pc1 = &b; */

/*     *pc2 = b; */
    pc2 = &b;

    printf ("\n\n");

    printf ("After\n");
    printf ("pc1=%p\n", pc1);
    printf ("*pc1=%c\n", *pc1);
    printf ("pc2=%p\n", pc2);
    printf ("*pc2=%c\n", *pc2);

    return EXIT_SUCCESS;
}

然而，我不得不写一个小程序来得到答案。如果我不在机器旁（比如在面试时），我将无法回答这个问题

有人能通过评论上面的例子解释一下

const

关键字是如何工作的吗

char * const a;

表示指针是常量且不可变的，但指向的数据不是。
在这种情况下，您可以使用

const_cast

（在C++中）或C风格的cast来消除常量，因为数据本身不是常量

const char * a;

表示无法使用指针a写入指向的数据。

---

使用

const_cast

（C++）或C样式cast来丢弃常量在这种情况下会导致未定义的行为

第一个是指向字符的常量指针，第二个是指向常量字符的指针。您没有触及代码中的所有案例：

char * const pc1 = &a; /* You can't make pc1 point to anything else */
const char * pc2 = &a; /* You can't dereference pc2 to write. */

*pc1 = 'c' /* Legal. */
*pc2 = 'c' /* Illegal. */

pc1 = &b; /* Illegal, pc1 is a constant pointer. */
pc2 = &b; /* Legal, pc2 itself is not constant. */

*a

可写，但

a

不可写；换句话说，您可以修改

a

指向的值，但不能修改

a

本身

a

是指向

char

的常量指针

a

可写，但

*a

不可写；换句话说，您可以修改

a

（将其指向新位置），但不能修改

a

指向的值

请注意，这与

char const * a;

---

在本例中，

a

是指向

const char

的指针。要解析复杂类型，请从变量开始，向左旋转，然后向外旋转。如果没有需要担心的数组或函数（因为这些数组或函数位于变量名的右侧），则会出现从右向左读取的情况

所以用

char*const a

您有

a

，它是指向

字符的
常量（
*
）指针。换句话说，您可以更改
a
指向的字符，但不能使
a
指向任何不同的字符

与
const char*b相反
您有
b
，它是指向
char
的指针（
*
），char
是
const
。您可以使
b
指向您喜欢的任何字符，但不能使用
*b=

当然，你也可以同时拥有两种味道的常量：
constchar*constcchar*const a
和
const char*a
之间的区别。很多时候，我们会搞不清楚它是常量指针还是指向常量变量的指针

怎么读？按照下面的简单步骤识别上两种

让我们看看如何阅读下面的声明

char * const a;

const char * a;

从右向左读

现在从
a
开始

一,。与
a
相邻的是
const

字符*
（常量a）

--->所以
a
是一个
常数
（？）

二,。现在继续你会得到
*

字符
（*（常量a））

--->所以
a
是一个
常量
指针
指向
（？）

三,。往前走，就会有
char

（char（*（const a）））

--->
a
是一个
常量
指针
指向
字符
变量

a is constant pointer to character variable. 

它不容易读吗

类似于第二次声明

char * const a;

const char * a;

现在再次从
a
开始

一,。与
a
相邻的是
*

--->所以
a
是指向（？？）的
指针

二,。现在有了
char

--->所以
a
是
指针
字符

那没有任何意义！！！所以洗牌
指针
和
字符

--->所以
a
是
字符
指针
指向
（？？？）

三,。现在您有了
常量

--->所以
a
是
字符
指针
指向
常数
变量

a is constant pointer to character variable. 

不过，尽管你们可以理解声明的含义，但让我们让它听起来更合理一些

a is pointer to constant character variable

理解差异的最简单方法是思考不同的可能性。有两个对象要考虑，指针和指向的对象（在这种情况下，‘a’是指针的名称，指向的对象是未命名的，char类型的对象）。可能性是：

没有什么是恒定的
指针是常量
指向的对象是const
指针和指向的对象都是常量
这些不同的可能性可以用C表示如下：

char*a
字符*常数a
常量字符*a
常量字符*常量a
我希望这说明了上述可能的差异是很好的答案。以下是记住这一点的简单方法：

a是指针

*a是价值

现在如果你说“const a”，那么指针就是const。（即字符*常数a；）

如果你说“const*a”，那么这个值就是const。（即const char*a；）
您可以使用cdecl实用程序或其在线版本，如

例如：

void（*x）（int（*[]）（）
是一个
将x声明为指向函数的指针（指向返回int的函数的指针数组）返回void
尝试以简单的方式回答：

char * const a;  => a is (const) constant (*) pointer of type char {L <- R}. =>( Constant Pointer )
const char * a;  => a is (*) pointer to char constant             {L <- R}. =>( Pointer to Constant)

这意味着一旦常数指针指向某个东西，它就是永远

指针
a
仅指向
b

但是，您可以更改
b
的值，例如：

char b='a';
char * const a =&b;

printf("\n print a  : [%c]\n",*a);
*a = 'c';
printf("\n now print a  : [%c]\n",*a);

指向常量的指针：

无法更改指针指向的值

const char *a;
char b = 'b';
const char * a =&b;
char c;
a=&c; //legal

*a = 'c'; // illegal , *a is pointer to constant can't change!.

这表示指向常量字符的指针。
例如

此处
a
指向一个常量字符（'s'，在本例中）。您不能使用<
const char *a;
char b = 'b';
const char * a =&b;
char c;
a=&c; //legal

*a = 'c'; // illegal , *a is pointer to constant can't change!.

const char * a;

char b='s';
const char *a = &b;

char * const a=&b

void Foo( int * ptr,
         int const * ptrToConst,
         int * const constPtr,
         int const * const constPtrToConst ) 
{ 
    *ptr = 0; // OK: modifies the "pointee" data 
    ptr = 0; // OK: modifies the pointer 

    *ptrToConst = 0; // Error! Cannot modify the "pointee" data
     ptrToConst = 0; // OK: modifies the pointer 

    *constPtr = 0; // OK: modifies the "pointee" data 
    constPtr = 0; // Error! Cannot modify the pointer 

    *constPtrToConst = 0; // Error! Cannot modify the "pointee" data 
    constPtrToConst = 0; // Error! Cannot modify the pointer 
}