C语言const指针修饰全解析

const在C语言中修饰指针时，决定了是限制修改指针本身还是其指向的数据。1. const修饰指针指向的内容：如const int p或int const p，表示不能通过p修改其指向的值，但可以改变p指向其他变量；2. const修饰指针本身：如int const p，表示p一旦初始化便不能再指向其他变量，但可通过p修改其所指向的值；3. const同时修饰指针和指向内容：如const int const p或int const const p，表示既不能修改指针指向的值，也不能改变指针指向其他变量。此外，在函数参数中使用const指针可防止意外修改数据、提高代码可读性、帮助编译器优化，并能安全传递字面量字符串。与typedef结合时需注意const修饰的对象，例如typedef char String; const String p等价于char const p，而typedef const char ConstString; ConstString p等价于const char *p。最后，将const变量赋值给非const变量是合法且安全的，但将const指针强制转换为非const指针并修改原const值会导致未定义行为，应尽量避免此类操作以确保程序稳定性。

const在C语言中修饰指针时，决定了指针本身还是指针指向的数据是否可以修改。简单来说，它可以限制你通过这个指针去修改某些东西。

解决方案

const修饰指针有三种主要情况，理解它们之间的区别至关重要：

1. const修饰指针指向的内容：

   const int *p;
   int const *p; // 与上面等价，只是写法不同

   这意味着，你不能通过p来修改它指向的int变量的值。但是，p本身可以指向其他的int变量。例如：

   int a = 10;
   int b = 20;
   const int *p = &a;
   
   // *p = 30;  // 错误！不能通过p修改a的值
   p = &b;     // 正确！p可以指向其他变量

   想象一下，你有一个“只读”的遥控器，只能看电视，不能换台。

2. const修饰指针本身：

   int * const p;

   这意味着，p一旦初始化，就不能再指向其他的int变量。但是，你可以通过p来修改它指向的int变量的值。例如：

   int a = 10;
   int * const p = &a;
   
   *p = 30;     // 正确！可以通过p修改a的值
   // p = &b;  // 错误！p不能指向其他变量

   这次，遥控器和电视绑定了，永远只能控制这台电视，但是你可以用遥控器换台。

3. const同时修饰指针和指针指向的内容：

   const int * const p;
   int const * const p; // 与上面等价，只是写法不同

   这意味着，p一旦初始化，既不能再指向其他的int变量，也不能通过p来修改它指向的int变量的值。例如：

   int a = 10;
   const int * const p = &a;
   
   // *p = 30;  // 错误！不能通过p修改a的值
   // p = &b;  // 错误！p不能指向其他变量

   这个遥控器是终极版，和电视绑定，而且只能看，啥都不能干。

副标题1

const修饰指针在函数参数中的应用：为什么使用 const 指针参数？

在函数参数中使用const修饰指针，是一种良好的编程习惯，主要有以下几个原因：

• 防止意外修改： 最直接的原因是防止函数内部意外修改指针指向的数据。如果函数只需要读取数据，而不需要修改数据，那么使用const修饰指针参数可以避免潜在的错误。例如，一个计算数组平均值的函数，应该使用const来修饰数组指针。
• 提高代码可读性： const关键字可以清晰地表明函数的意图。看到const，就知道函数不会修改指针指向的数据，这有助于理解和维护代码。
• 编译器优化： const关键字可以帮助编译器进行优化。编译器可以根据const信息，进行更有效的代码生成。
• 传递字面量字符串： 字面量字符串（例如 "hello"）在C语言中通常存储在只读内存区域。如果一个函数接受字符串指针作为参数，并且没有使用 const 修饰，那么传递字面量字符串给该函数可能会导致警告或错误。 使用 const char* 作为参数类型可以安全地接收字面量字符串。

举个例子：

#include 

// 计算数组元素的和，不修改数组内容
int sum_array(const int *arr, int size) {
    int sum = 0;
    for (int i = 0; i < size; i++) {
        sum += arr[i];
    }
    return sum;
}

int main() {
    int numbers[] = {1, 2, 3, 4, 5};
    int total = sum_array(numbers, sizeof(numbers) / sizeof(numbers[0]));
    printf("Sum: %d\n", total);

    // 传递字面量字符串
    const char* message = "This is a constant string";
    printf("%s\n", message);

    return 0;
}

在这个例子中，sum_array函数使用const int *arr来接收数组指针，表明该函数不会修改数组的内容。

副标题2

const与typedef结合使用： 容易混淆的地方和正确用法。

typedef用于为已有的数据类型定义一个新的名字。当const和typedef一起使用时，需要特别注意const修饰的是什么。

一个常见的误解是，typedef定义的类型名会被简单地替换到const声明中。但事实并非如此。const修饰的是typedef定义的类型。

例如：

typedef char *String;
const String p; // 等价于 char * const p;  p是一个指向char的常量指针，指针本身不能修改

这里，String被定义为char *，然后const String p表示p是一个String类型的常量，也就是一个指向char的常量指针。这意味着p本身不能被修改，即不能指向其他的字符串，但p指向的字符串内容是可以修改的。

如果要定义一个指向const char的指针，应该这样写：

typedef const char *ConstString;
ConstString p; // 等价于 const char *p; p是一个指向const char的指针，可以通过更改指针指向其他const char

或者直接：

const char *String;

为了避免混淆，建议在typedef和const一起使用时，仔细考虑const应该修饰什么。最好的方式是，尽量避免将指针类型用typedef重命名，除非有充分的理由。

副标题3

const的"穿透性"：const变量赋值给非const变量时会发生什么？

在C语言中，将const变量赋值给非const变量是允许的，但可能会引发一些问题，涉及到const的"穿透性"。

const int a = 10;
int b = a; // 正确，const int 可以赋值给 int

在这个例子中，const int a的值被赋给了int b。这样做是合法的，因为我们只是将一个只读的值拷贝到了一个可写的变量中。b可以被修改，而a仍然是只读的。

但是，如果涉及到指针，情况就变得复杂一些：

const int a = 10;
const int *p = &a;
int *q = (int *)p; // 需要强制类型转换，但这样做是危险的！

*q = 20; // 尝试修改a的值，可能导致未定义行为
printf("a = %d\n", a); // a的值可能被修改，也可能没有

在这个例子中，我们首先定义了一个const int a和一个指向a的const指针p。然后，我们尝试将const int *类型的p强制转换为int *类型的q。虽然强制类型转换可以绕过编译器的类型检查，但是这样做是非常危险的。

通过q修改a的值，违反了const的语义。这种行为的结果是未定义的，可能导致程序崩溃，或者a的值被修改，或者程序表现出其他不可预测的行为。

总结：

• 将const变量的值赋给非const变量是安全的，因为只是值的拷贝。
• 将const指针强制转换为非const指针是危险的，因为它允许你通过非const指针修改const变量的值，这违反了const的语义，可能导致未定义行为。

因此，应该尽量避免将const指针强制转换为非const指针。如果确实需要这样做，应该仔细考虑其后果，并确保程序的行为是可预测的。最好的做法是，从设计上避免这种情况的发生。