当前位置： 首页 > news >正文

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

news 2025/5/15 13:39:03

目录

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 的指向。

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: 10return 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;
}

http://www.mrgr.cn/news/42556.html

相关文章：

  • 插入排序：直接插入排序、希尔排序
  • Java高效编程（15）：最小化类与成员的可见性
  • 5G NR coreset 简介
  • (C语言贪吃蛇)16.贪吃蛇食物位置随机(完结撒花)
  • Ubuntu18.04配置OpenPCDet并运行demo过程记录
  • Chromium 硬件加速开关c++
  • Redis: 集群高可用之MOVED转向和ASK转向解决方案
  • [云] DockerCoins 练习笔记
  • 电子电路元件器介绍与选型——晶振
  • 基于Apache和Tomcat的负载均衡实验报告
  • 考研论坛平台|考研论坛小程序系统|基于java和微信小程序的考研论坛平台小程序设计与实现(源码+数据库+文档)
  • (C语言贪吃蛇)14.用绝对值方式解决不合理的走位
  • Redis缓存
  • NVIDIA机密计算文档
  • AAA Mysql与redis的主从复制原理
  • 探索画中画视频剪辑：创意无限，轻松实现
  • vue3+vite@4+ts+elementplus创建项目详解
  • HTML详解
  • macos安装git并连接gitCode远程仓库
  • 创建实体类pojo实现Serializable接口