在C中声明指针类型的参数时使用“const”

我知道将

const

放在

p

的类型之前可以保护

p

指向的对象，但是：

void f（int*const p）

这样的声明合法吗

此外，以下各项之间的区别是什么：

void f（const int*p）

void f（int*const p）

void f（常数int*const p）

void f（int const*p）

这样的声明合法吗

是的，尽管效果与

const

在

p

的类型之前不同

此外，以下各项之间的区别是什么：

void f（const int*p）

将

const

放在

p

的类型之前可以保护

p

指向的对象

例如：

void f(const int *p) {
   int j;

   *p = 0;       //WRONG
   p = &j;       //legal
}

void f(int * const p) {
   int j;

   *p = 0;       //legal
   p = &j;       //WRONG
}

void f(const int * const p) {
   int j;

   *p = 0;       //WRONG
   p = &j;       //WRONG
}

void f（int*const p）

将

const

放在

p

的类型之后可以保护

p

本身

例如：

void f(const int *p) {
   int j;

   *p = 0;       //WRONG
   p = &j;       //legal
}

void f(int * const p) {
   int j;

   *p = 0;       //legal
   p = &j;       //WRONG
}

void f(const int * const p) {
   int j;

   *p = 0;       //WRONG
   p = &j;       //WRONG
}

由于

p

仅仅是另一个功能的副本，因此该功能不常使用 指针，几乎没有任何理由保护它。更为罕见的是 下一个案例

void f（常数int*const p）

这里的

const

同时保护

p

及其指向的对象

例如：

void f(const int *p) {
   int j;

   *p = 0;       //WRONG
   p = &j;       //legal
}

void f(int * const p) {
   int j;

   *p = 0;       //legal
   p = &j;       //WRONG
}

void f(const int * const p) {
   int j;

   *p = 0;       //WRONG
   p = &j;       //WRONG
}

void f（int const*p）

这与

void f（const int*p）

相同。 见第1点

这样的声明合法吗

是的，尽管效果与

const

在

p

的类型之前不同

此外，以下各项之间的区别是什么：

void f（const int*p）

将

const

放在

p

的类型之前可以保护

p

指向的对象

例如：

void f(const int *p) {
   int j;

   *p = 0;       //WRONG
   p = &j;       //legal
}

void f(int * const p) {
   int j;

   *p = 0;       //legal
   p = &j;       //WRONG
}

void f(const int * const p) {
   int j;

   *p = 0;       //WRONG
   p = &j;       //WRONG
}

void f（int*const p）

将

const

放在

p

的类型之后可以保护

p

本身

例如：

void f(const int *p) {
   int j;

   *p = 0;       //WRONG
   p = &j;       //legal
}

void f(int * const p) {
   int j;

   *p = 0;       //legal
   p = &j;       //WRONG
}

void f(const int * const p) {
   int j;

   *p = 0;       //WRONG
   p = &j;       //WRONG
}

由于

p

仅仅是另一个功能的副本，因此该功能不常使用 指针，几乎没有任何理由保护它。更为罕见的是 下一个案例

void f（常数int*const p）

这里的

const

同时保护

p

及其指向的对象

例如：

void f(const int *p) {
   int j;

   *p = 0;       //WRONG
   p = &j;       //legal
}

void f(int * const p) {
   int j;

   *p = 0;       //legal
   p = &j;       //WRONG
}

void f(const int * const p) {
   int j;

   *p = 0;       //WRONG
   p = &j;       //WRONG
}

void f（int const*p）

这与

void f（const int*p）

相同。 见第1点

---

您忘记了一个案例：

void f（int-const*p）

，它与

void f（const-int*p）

相同。谢谢，我将编辑问题以包含此案例。@Rrz0；你为什么认为这个问题应该再问一遍？你没有发现类似的问题和答案吗？你认为其他问题的答案不能很好地解释这个话题吗？如果你有更好的解释，那么你不认为你可以把它作为一个答案发布在其他类似的帖子上吗？你忘记了一个案例：

void f（int-const*p）

，它与

void f（const-int*p）

相同。谢谢，我会编辑这个问题以包含这个案例。@Rrz0；你为什么认为这个问题应该再问一遍？你没有发现类似的问题和答案吗？你认为其他问题的答案不能很好地解释这个话题吗？如果你有更好的解释，那么你不认为你可以把它作为一个答案发布在其他类似的帖子上吗？