36 指针与 const 的多种搭配：指向常量的指针、常量指针、指向常量的常量指针、指针到指针的常量（涉及双重指针）

1 指向常量的指针

1.1 概念

1.2 语法格式

1.3 声明与初始化

1.4 实际应用

1.4.1 保护数据

1.4.2 函数参数

1.4.3 字符串常量

2 常量指针

2.1 概念

2.2 语法格式

2.3 声明与初始化

2.4 实际应用

2.4.1 保护指针指向的地址

2.4.2 数组处理

2.4.3 函数参数

3 指向常量的常量指针

3.1 概念

3.2 语法格式

3.3 声明与初始化

3.4 实际应用

3.4.1 保护数据和指针

3.4.2 函数参数

4 指针到指针的常量

4.1 概念

4.2 语法格式

4.2.1 指向常量的指针的指针

4.2.2 指向常量的指针的常量指针

4.2.3 指向常量的常量指针的指针

4.3 声明与初始化

4.3.1 指向常量的指针的指针

4.3.2 指向常量的指针的常量指针

4.3.3 指向常量的常量指针的指针

4.4 实际应用

4.4.1 保护数据和指针

4.4.2 函数参数

1 指向常量的指针

1.1 概念

指向常量的指针（Pointer to Const）是指其指向的值是常量（const 修饰的值），即这个指针所指向的存储单元的内容不能被修改。指针本身仍然可以改变，即它可以指向不同的地址。

1.2 语法格式

const 数据类型 *指针变量名;

这里的 const 数据类型表示指针所指向的数据是常量，而 * 表示指针。

1.3 声明与初始化

“指向常量的指针” 可以在声明时进行初始化，也可以在声明后再进行初始化。一旦初始化后，可以通过该指针访问数据，但不能修改数据。

const int a = 10;
int b = 20;// 声明并初始化一个指向常量的指针 p，使其指向变量 a
const int *p = &a;// 通过 p 访问 a 的值
printf("Value of a: %d\n", *p); // 正确，可以访问 a 的值// 通过 p 修改 a 的值
// *p = 15; // 错误，不能通过 p 修改 a// 改变 p 的指向
p = &b; // 正确，可以改变 p 的指向// 通过 p 访问 b 的值
printf("Value of b: %d\n", *p); // 正确，可以访问 b 的值// 通过 p 修改 b 的值
// *p = 25; // 错误，不能通过 p 修改 b

1.4 实际应用

1.4.1 保护数据

“指向常量的指针” 可以确保指针所指向的数据不会被意外修改，从而提高代码的安全性和可维护性。

const int a = 10;void printValue(const int *p) {printf("Value: %d\n", *p);
}int main() {const int *p = &a;printValue(p); // 输出: Value: 10return 0;
}

在这个例子中，printValue 函数的参数 p 是一个指向常量的指针，确保在函数内部不能通过 p 修改所指向的数据。

1.4.2 函数参数

在函数参数中使用 “指向常量的指针” 可以确保传递的指针所指向的数据不会被修改，从而避免意外的副作用。

const int a = 10;
const int b = 20;void swapValues(const int *p1, const int *p2) {// 交换两个指针所指向的数据// 这里假设我们有一个函数 swapInts 来交换两个整数// swapInts(*p1, *p2); // 错误，不能通过 p1 或 p2 修改数据
}int main() {const int *p1 = &a;const int *p2 = &b;swapValues(p1, p2); // 调用函数return 0;
}

在这个例子中，swapValues 函数的参数 p1 和 p2 都是指向常量的指针，确保在函数内部不能修改 p1 和 p2 所指向的数据。

1.4.3 字符串常量

在处理字符串常量时，使用 “指向常量的指针” 可以确保字符串内容不会被修改。

void printString(const char *str) {while (*str != '\0') {putchar(*str);str++;}putchar('\n');
}int main() {const char *str = "Hello, World!";printString(str); // 输出: Hello, World!// 尝试修改字符串内容// *str = 'h'; // 错误，不能通过 str 修改字符串内容return 0;
}

在这个例子中，printString 函数的参数 str 是一个指向常量字符的指针，确保在函数内部不能修改字符串内容。

2 常量指针

2.1 概念

常量指针（Const Pointer）是指指针本身是一个常量，一旦初始化后，就不能再改变其指向的地址。这意味着指针所指向的内存地址是固定的，但指针所指向的数据是可以修改的。

2.2 语法格式

数据类型 *const 指针变量名;

这里的 *const 表示指针本身是常量，而数据类型表示指针所指向的数据的类型。

2.3 声明与初始化

常量指针必须在声明时进行初始化，因为一旦初始化后，就不能再改变其指向的地址。

int a = 10;
int b = 20;// 声明并初始化一个常量指针 p，使其指向变量 a
int *const p = &a;// 通过 p 修改 a 的值
*p = 15; // 正确，可以修改 a 的值// 尝试改变 p 的指向
// p = &b; // 错误，不能改变 p 的指向

2.4 实际应用

2.4.1 保护指针指向的地址

常量指针可以确保指针指向的地址不会被意外修改，防止指针的误操作（如错误地改变指针的指向），从而提高代码的安全性和可维护性。

2.4.2 数组处理

在处理数组时，如果希望保护数组的起始地址不被改变，可以使用常量指针来指向数组的首元素。这样，即使函数内部对数组进行了处理，也不会改变数组的起始地址。

#include <stdio.h>// 函数声明，使用常量指针（仅指针本身是常量）作为参数
void printArray(int *const arr, int size);int main()
{int myArray[] = {1, 2, 3, 4, 5};int size = sizeof(myArray) / sizeof(myArray[0]);// 调用函数，传递数组和大小printArray(myArray, size);for (int i = 0; i < size; i++){printf("%d ", myArray[i]); // 100 100 100 100 100}return 0;
}// 函数定义，使用常量指针（仅指针本身是常量）作为参数
void printArray(int *const arr, int size)
{// 由于 arr 是 int *const，我们不能改变 arr 的值（即它指向的地址）for (int i = 0; i < size; i++){printf("%d ", arr[i]);// 1 2 3 4 5arr[i] = 100;}printf("\n");
}

在这个示例中，printArray 函数保证不会改变 arr 的指向，但默认情况下仍然可以通过 arr 来读取数组的内容。

2.4.3 函数参数

在函数中，如果不希望函数内部改变传入指针的指向，可以将参数声明为常量指针。这样，函数内部就不能修改指针的值，但可以通过指针来访问和修改它所指向的数据。

void printArray(int *const arr, int size) {for (int i = 0; i < size; i++) {printf("%d ", arr[i]);}printf("\n");
}int main() {int array[] = {1, 2, 3, 4, 5};int size = sizeof(array) / sizeof(array[0]);printArray(array, size);return 0;
}

在这个例子中，printArray 函数的参数 arr 是一个常量指针，确保在函数内部不会改变 arr 的指向。

3 指向常量的常量指针

3.1 概念

指向常量的常量指针（Const Pointer to Const）是指指针本身是一个常量，同时指针所指向的数据也是一个常量。这意味着既不能通过该指针修改指针所指向的数据，也不能改变指针本身的指向。

3.2 语法格式

const 数据类型 *const 指针变量名;

这里的 const 数据类型表示指针所指向的数据是常量，而 *const 表示指针本身是常量。

3.3 声明与初始化

指向常量的常量指针必须在声明时进行初始化，因为一旦初始化后，就不能再改变其指向的地址，也不能通过该指针修改所指向的数据。

const int a = 10;
const int b = 20;// 声明并初始化一个指向常量的常量指针 p，使其指向变量 a
const int *const p = &a;// 通过 p 修改 a 的值
// *p = 15; // 错误，不能通过 p 修改 a// 尝试改变 p 的指向
// p = &b; // 错误，不能改变 p 的指向

3.4 实际应用

3.4.1 保护数据和指针

指向常量的常量指针可以确保指针指向的数据不会被修改，同时指针本身的指向也不会被改变，从而提供更高的数据安全性和代码可维护性。

const int a = 10;
const int b = 20;void printValue(const int *const ptr) {printf("Value: %d\n", *ptr);
}int main() {const int *const p = &a;printValue(p); // 输出: Value: 10return 0;
}

在这个例子中，printValue 函数的参数 ptr 是一个指向常量的常量指针，确保在函数内部既不能修改 ptr 所指向的数据，也不能改变 ptr 的指向。