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

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: 10

    return 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 5
        arr[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: 10

    return 0;
}

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

3.4.2 函数参数

在函数参数中使用 “指向常量的常量指针” 可以确保传递的指针不会在函数内部被重新赋值，同时确保指针所指向的数据不会被修改。

const int a = 10;
const int b = 20;

void swapPointers(const int * const ptr1, const int * const ptr2) {
    // 交换两个指针所指向的数据
    // 这里假设我们有一个函数 swapInts 来交换两个整数
    // swapInts(*ptr1, *ptr2); // 错误，不能通过 ptr1 或 ptr2 修改数据
}

int main() {
    const int * const p1 = &a;
    const int * const p2 = &b;

    swapPointers(p1, p2); // 调用函数

    return 0;
}

4 指针到指针的常量

4.1 概念

“指针到指针的常量” 是指涉及双重指针的情况，其中指针本身或其指向的数据可以是常量。根据不同的组合，可以有以下几种情况：

指向常量的指针的指针：指针所指向的指针所指向的数据是常量。
指向常量的指针的常量指针：指针本身是常量，同时它所指向的指针所指向的数据是常量。
指向常量的常量指针的指针：指针所指向的指针本身是常量，同时它所指向的数据也是常量。

4.2 语法格式

4.2.1 指向常量的指针的指针

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

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

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

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

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

4.3 声明与初始化

4.3.1 指向常量的指针的指针

const int a = 10;
const int b = 20;
const int *p = &a; // p 指向 a
const int **pp = &p; // pp 指向 p

// 通过 pp 修改 a 的值
// **pp = 15; // 错误，不能通过 pp 修改 a

// 改变 p 的指向
p = &b; // 正确，可以改变 p 的指向

// 改变 pp 的指向
// pp = &q; // 正确，可以改变 pp 的指向

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

const int a = 10;
const int b = 20;
const int *p = &a; // p 指向 a
const int *const *pp = &p; // pp 指向 p

// 通过 pp 修改 a 的值
// **pp = 15; // 错误，不能通过 pp 修改 a

// 改变 p 的指向
// p = &b; // 错误，不能改变 p 的指向

// 改变 pp 的指向
// pp = &q; // 正确，可以改变 pp 的指向

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

const int a = 10;
const int b = 20;
const int * const p = &a; // p 指向 a
const int *const *const pp = &p; // pp 指向 p

// 通过 pp 修改 a 的值
// **pp = 15; // 错误，不能通过 pp 修改 a

// 改变 p 的指向
// p = &b; // 错误，不能改变 p 的指向

// 改变 pp 的指向
// pp = &q; // 错误，不能改变 pp 的指向

4.4 实际应用

4.4.1 保护数据和指针

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

const int a = 10;
const int b = 20;

void printValue(const int * const * const pp) {
    printf("Value: %d\n", **pp);
}

int main() {
    const int * const p = &a;
    const int * const * const pp = &p;

    printValue(pp); // 输出: Value: 10

    return 0;
}

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

4.4.2 函数参数

在函数参数中使用 “指针到指针的常量” 可以确保传递的指针不会在函数内部被重新赋值，同时确保指针所指向的数据不会被修改。

const int a = 10;
const int b = 20;

void swapPointers(const int * const * const pp1, const int * const * const pp2) {
    // 交换两个指针所指向的数据
    // 这里假设我们有一个函数 swapInts 来交换两个整数
    // swapInts(**pp1, **pp2); // 错误，不能通过 pp1 或 pp2 修改数据
}

int main() {
    const int * const p1 = &a;
    const int * const p2 = &b;
    const int * const * const pp1 = &p1;
    const int * const * const pp2 = &p2;

    swapPointers(pp1, pp2); // 调用函数

    return 0;
}