解码C语言指针-尧图网站建设

📅 发布时间：2026/6/18 14:13:08

一、指针的定义与本质

1. 指针是什么？

指针是一种 存储变量内存地址 的特殊变量。所有数据存储在内存中，每个内存单元都有唯一地址（编号），指针通过记录地址实现对数据的间接访问。

2. 指针的核心作用

直接操作内存：动态内存分配、硬件编程等。
提高效率：传递大对象时避免复制（如结构体）。
灵活数据结构：实现链表、树、图等动态结构。

二、指针基本语法

1. 声明指针

数据类型 *指针变量名;// *表示这是个指针变量

示例：

int *p;// p指向int类型变量
char *str;// str指向char类型变量

2. 指针初始化

取地址操作符 &：获取变量的内存地址。

int num = 10;
int *p = &num;// p指向num的地址

直接赋值（需确保地址合法）：

int *p = (int *)0x00007FFF1234;// 避免直接操作未知地址

三、指针的解引用

解引用操作符 * ****：通过指针访问或修改目标地址的数据。

int num = 10;
int *p = &num;printf("num的值 = %d\n", *p);// 输出10（访问值）
*p = 20;// 修改num为20

四、指针的算术运算

指针的加减操作以 数据类型大小 为单位进行偏移。

1. 指针与整数运算

int arr[5] = {1, 2, 3, 4, 5};
int *p = arr;// p指向arr[0]p++;// p指向arr[1]（地址+4字节，假设int为4字节）
printf("%d\n", *p);// 输出2p += 3;// p指向arr[4]
printf("%d\n", *p);// 输出5

2. 指针之间的减法

计算两个指针之间的元素距离（同类型指针）：

int *p1 = &arr[0];
int *p2 = &arr[4];
printf("距离 = %ld\n", p2 - p1);// 输出4（间隔4个元素）

五、多级指针

二级指针：指向指针的指针。

int num = 10;
int *p = &num;//数据类型 *指针变量名;
int **pp = &p;// pp指向p的地址
printf("%d\n", **pp);// 通过二级指针访问num的值 → 输出10

1. 遍历二维数组（数组指针）

#include <stdio.h>int main() {int matrix[2][3] = {{1, 2, 3}, {4, 5, 6}};int (*p)[3] = matrix;// 指向第一行的地址for (int i = 0; i < 2; i++) {for (int j = 0; j < 3; j++) {printf("%d ", p[i][j]);// 等价于 *(*(p + i) + j)}printf("\n");}return 0;
}

六、指针&数组&字符串

1. 数组名的本质

数组名是数组首元素的地址常量（不可修改）。

int arr[3] = {10, 20, 30};
int *p = arr;// p指向arr[0]
printf("%d\n", *(p + 1));// 右移一个int单位 → 输出20

2. 指针遍历数组

for (int *ptr = arr; ptr < arr + 3; ptr++) {printf("%d ", *ptr);// 输出10 20 30
}

3. 遍历字符串

char *p = "Hello";
while (*p != '\0') {printf("%c ", *p);// 输出 H e l l op++;
}

4. 字符串拼接（动态分配）

#include <stdlib.h>
#include <string.h>
char *concat(const char *s1, const char *s2) {char *result = malloc(strlen(s1) + strlen(s2) + 1);// +1 为 '\0'strcpy(result, s1);strcat(result, s2);return result;
}// 使用示例
char *str = concat("Hello, ", "world!");
printf("%s\n", str);// 输出 Hello, world!
free(str);// 必须释放内存

5. 字符串数组（指针数组）

char *fruits[] = {"Apple", "Banana", "Cherry"};// 指针数组
for (int i = 0; i < 3; i++) {printf("%s\n", fruits[i]);// 输出各水果名称
}
printf("%s\n",*(fruits + 1));//输出Banana,数组的第二个元素
printf("%c\n",*(*(fruits + 1) + 1));//输出a,Banana的第二个字符

七、指针与函数

1. 传递指针到函数

// 修改外部变量值
void increment(int *x) {(*x)++;
}int main() {int a = 5;increment(&a);// a变为6return 0;
}

2. 返回指针的函数（指针函数）

/* 返回数组最大元素的地址,只能返回静态变量的地址、动态开辟(malloc)的地址，全局变量
的地址等，不能返回局部变量的地址（否则程序会崩溃）
*/
int* find_max(int *arr, int size) {int *max = arr;for (int *p = arr; p < arr + size; p++) {if (*p > *max) max = p;}return max;
}
int* find_max(int *arr, int size) {static int max = *arr;for (int *p = arr; p < arr + size; p++) {if (*p > max) max = *p;}return &max; 
}

3. 函数指针

指向函数的指针，用于回调机制：

int add(int a, int b) { return a + b; }
int (*func_p)(int, int) = add;// 声明函数指针
printf("%d\n", func_p(3, 4));// 输出7

**八、`void *` 指针**

通用指针，可指向任意类型数据。
使用前需强制类型转换。

void *ptr;
int x = 10;
ptr = (void *)&x;// 合法
printf("%d\n", *(int *)ptr);// 需转换为int*

九、

核心规则：const 的位置决定保护的对象

const 在 * 的左边，保护的是指针所指向的数据（*p 不可变）。

const 在 * 的右边，保护的是指针本身（p 不可变）。

1. 指向常量的指针（Pointer to Constant）

格式： const 类型 *ptr 或 类型 const *ptr

含义： 指针 ptr 可以指向不同的地址，但不能通过 ptr 来修改它所指向的数据。

示例：

int a = 10, b = 20;// 指向常量的指针
const int *ptr1 = &a;// ptr1 指向一个const int
int const *ptr2 = &a;// 等价写法
// *ptr1 = 15;  // 错误！不能通过ptr1修改数据
a = 15;// 合法，a本身不是constptr1 = &b;// 合法，ptr1可以指向其他地址
// *ptr1 = 25;  // 错误！仍然不能通过ptr1修改数据

2. 指针常量（Constant Pointer）

格式： 类型 * const ptr

含义： 指针 ptr 自身是常量，一旦初始化就不能再指向其他地址，但可以通过 ptr 修改它所指向的数据。

示例：

int x = 10, y = 20;// 指针常量
int * const ptr = &x;// ptr是常量指针
*ptr = 15;// 合法，可以修改指向的数据
// ptr = &y;    // 错误！ptr本身是常量，不能改变指向

3. 指向常量的指针常量（Constant Pointer to Constant）

格式： const 类型 * const ptr

含义： 既不能修改指针 ptr 的指向，也不能通过 ptr 修改所指向的数据。

示例：

const int z = 30;
int w = 40;// 指向常量的指针常量
const int * const ptr = &z;// *ptr = 35;    // 错误！不能修改数据
// ptr = &w;     // 错误！不能修改指针指向
int read = *ptr;// 合法，只能读取

总结表格（带变量名）

声明格式	指针(ptr)是否可修改	*数据(ptr)是否可修改**	说明
`int *ptr`	是	是	普通指针
`const int *ptr`	是	否	指向常量的指针
`int * const ptr`	否	是	指针常量
`const int * const ptr`	否	否	指向常量的指针常量

十、野指针

1. 野指针

野指针是指指向无效内存地址的指针。这些指针通常指向已经被释放或未分配的内存区域。对野指针进行操作会导致未定义行为。

2.主要成因

成因一：指针未初始化

int *ptr;// 未初始化，值是随机的垃圾值
*ptr = 10;// 危险！向随机内存地址写入数据
printf("%d", *ptr);// 可能导致程序崩溃

成因二：malloc后未检查或释放后继续使用

int *ptr = (int*)malloc(sizeof(int));
if (ptr != NULL) {*ptr = 100;
}
free(ptr);// 释放内存
// ptr现在成为野指针*ptr = 200;// 危险！访问已释放的内存
printf("%d", *ptr);// 未定义行为

成因三：指向局部变量（函数返回后）

int* createWildPointer() 
{int local = 42;return &local;// 返回局部变量的地址
}int main() {int *ptr = createWildPointer();// ptr是野指针printf("%d", *ptr);// 危险！local已销毁return 0;
}

成因四：指针越界访问

int arr[5] = {1, 2, 3, 4, 5};
int *ptr = arr;for (int i = 0; i < 10; i++) 
{// 越界访问printf("%d ", *(ptr + i));// 后5次是野指针访问
}

成因五：指针运算错误

int *ptr = (int*)malloc(5 * sizeof(int));
// ... 使用ptr
free(ptr);int *ptr2 = ptr + 2;// ptr2也是野指针

3. 野指针的危害

程序崩溃：段错误（Segmentation Fault）
数据损坏：意外修改其他有效数据
安全漏洞：可能被利用进行攻击
难以调试：错误表现随机，难以追踪

4. 避免野指针的方法

方法一：总是初始化指针

int *ptr = NULL;// 初始化为NULL
int *ptr2 = (int*)malloc(sizeof(int));// 或初始化为有效地址
if (ptr2 != NULL) {*ptr2 = 10;
}

方法二：释放后立即置NULL

int *ptr = (int*)malloc(sizeof(int));
if (ptr != NULL) {*ptr = 100;printf("%d\n", *ptr);
}free(ptr);// 释放内存
ptr = NULL;// 立即置NULL
// 安全检查
if (ptr != NULL) 
{printf("%d\n", *ptr);// 不会执行} 
else 
{printf("指针已释放\n");
}

方法三：避免返回局部变量地址

// 错误做法
int* badFunction() {int local = 5;return &local;
}// 正确做法1：使用静态变量
int* goodFunction1() {static int staticVar = 5;// 静态变量生命周期延长return &staticVar;
}// 正确做法2：使用动态内存
int* goodFunction2() {int *dynamicVar = (int*)malloc(sizeof(int));if (dynamicVar != NULL) {*dynamicVar = 5;}return dynamicVar;
}// 正确做法3：通过参数返回
void goodFunction3(int **result) {*result = (int*)malloc(sizeof(int));if (*result != NULL) {**result = 5;}
}

方法四：使用函数返回值检查

int *createArray(int size) {if (size <= 0) {return NULL;// 返回NULL而不是野指针}return (int*)malloc(size * sizeof(int));
}int main() {int *arr = createArray(5);if (arr == NULL) {printf("内存分配失败\n");return 1;}// 使用arr...free(arr);arr = NULL;return 0;
}

方法五：封装内存管理函数

// 安全的malloc封装
void* safeMalloc(size_t size) {void *ptr = malloc(size);if (ptr == NULL) {fprintf(stderr, "内存分配失败\n");exit(EXIT_FAILURE);}return ptr;
}// 安全的free封装
void safeFree(void **ptr) {if (ptr != NULL && *ptr != NULL) {free(*ptr);*ptr = NULL;// 自动置NULL}
}int main() {int *arr = (int*)safeMalloc(5 * sizeof(int));// 使用arr...safeFree((void**)&arr);// 自动置NULL// 现在arr为NULL，不会成为野指针return 0;
}

5. 检测野指针的工具

使用Valgrind（Linux）

gcc -g program.c -o program
valgrind --leak-check=full ./program

十一、动态内存分配

使用指针管理堆内存（需引入 <stdlib.h>）：

int *arr = (int *)malloc(5 * sizeof(int));// 分配5个int的空间
if (arr != NULL) {arr[0] = 100;
// 使用完毕后释放内存free(arr);arr = NULL;// 避免野指针
}

十二、指针的注意事项&应用场合

问题	说明	规避方法
野指针	指向未知内存的指针	初始化时置空，释放后置空
空指针解引用	对 `NULL` 指针进行操作导致崩溃	使用前检查指针是否为 `NULL`
内存泄漏	未释放动态分配的内存	确保每个 `malloc` 对应一个 `free`
指针类型不匹配	操作不同类型指针导致数据错误	避免强制类型转换的误用

当函数需要传递一个数组时，指针代替数组
当函数需要返回一个地址（例如函数需要返回数组）的时候，需要使用指针
实现。
当函数需要改变实参的时候，需要使用指针实现。-----形参改变实参

十三、代码示例

1. 指针操作基本流程

#include <stdio.h>
int main() {int a = 10;int *p = &a;printf("a的地址 = %p\n", (void *)p);// 输出地址（如0x7ffd...）printf("a的值 = %d\n", *p);// 输出10*p = 20;printf("修改后a的值 = %d\n", a);// 输出20return 0;
}

2. 动态数组操作

#include <stdio.h>
#include <stdlib.h>
int main() {int size = 5;int *arr = (int *)malloc(size * sizeof(int));if (arr == NULL) {printf("内存分配失败！\n");return 1;}for (int i = 0; i < size; i++) {arr[i] = i * 10;}for (int *p = arr; p < arr + size; p++) {printf("%d ", *p);// 输出0 10 20 30 40}free(arr);arr = NULL;return 0;
}

解码C语言指针

一、指针的定义与本质

1. 指针是什么？

2. 指针的核心作用

二、指针基本语法

1. 声明指针

2. 指针初始化

三、指针的解引用

四、指针的算术运算

1. 指针与整数运算

2. 指针之间的减法

五、多级指针

1. 遍历二维数组（数组指针）

六、指针&数组&字符串

1. 数组名的本质

2. 指针遍历数组

3. 遍历字符串

4. 字符串拼接（动态分配）

5. 字符串数组（指针数组）

七、指针与函数

1. 传递指针到函数

2. 返回指针的函数（指针函数）

3. 函数指针

八、void * 指针

九、

核心规则：const 的位置决定保护的对象

1. 指向常量的指针（Pointer to Constant）

2. 指针常量（Constant Pointer）

3. 指向常量的指针常量（Constant Pointer to Constant）

总结表格（带变量名）

十、野指针

1. 野指针

2.主要成因

成因一：指针未初始化

成因二：malloc后未检查或释放后继续使用

成因三：指向局部变量（函数返回后）

成因四：指针越界访问

成因五：指针运算错误

3. 野指针的危害

4. 避免野指针的方法

方法一：总是初始化指针

方法二：释放后立即置NULL

方法三：避免返回局部变量地址

方法四：使用函数返回值检查

方法五：封装内存管理函数

5. 检测野指针的工具

使用Valgrind（Linux）

十一、动态内存分配

十二、指针的注意事项&应用场合

十三、代码示例

1. 指针操作基本流程

2. 动态数组操作

**八、`void *` 指针**