C语言多级指针与函数指针：指针的高级用法

烛衔溟2025-11-12 21:02

本文献给：

希望深入理解C语言指针高级用法的你。如果你已经掌握基础指针，想要学习多级指针和函数指针的使用场景和技巧------本文将带你深入探索。

你将学到：

  1. 理解多级指针的概念和用法
  2. 掌握多级指针在动态内存分配中的应用
  3. 理解函数指针的概念和声明
  4. 掌握函数指针的实际应用场景
  5. 学会使用函数指针实现回调函数

让我们开始探索指针的高级世界！

目录

  • 第一部分：多级指针
    • [1. 多级指针的基本概念](#1. 多级指针的基本概念)
    • [2. 多级指针与动态二维数组](#2. 多级指针与动态二维数组)
    • [3. 多级指针在函数参数中的应用](#3. 多级指针在函数参数中的应用)
  • 第二部分：函数指针
    • [1. 函数指针的基本概念](#1. 函数指针的基本概念)
    • [2. 函数指针数组](#2. 函数指针数组)
    • [3. 回调函数](#3. 回调函数)
    • [4. 函数指针与qsort函数](#4. 函数指针与qsort函数)
  • 第三部分：总结
    • [1. 多级指针要点回顾](#1. 多级指针要点回顾)
    • [2. 函数指针要点回顾](#2. 函数指针要点回顾)
    • [3. 使用场景对比](#3. 使用场景对比)
  • 第四部分：常见问题解答

第一部分：多级指针

1. 多级指针的基本概念

多级指针就是指针的指针。例如，二级指针指向一级指针，三级指针指向二级指针，以此类推。

c 复制代码 
#include <stdio.h>

int main() {
    int value = 100;
    int *ptr1 = &value;     // 一级指针，指向int
    int **ptr2 = &ptr1;     // 二级指针，指向int*
    int ***ptr3 = &ptr2;    // 三级指针，指向int**

    printf("变量value的值: %d\n", value);
    printf("通过一级指针访问: %d\n", *ptr1);
    printf("通过二级指针访问: %d\n", **ptr2);
    printf("通过三级指针访问: %d\n", ***ptr3);

    // 打印地址
    printf("\n地址信息:\n");
    printf("value的地址: %p\n", (void*)&value);
    printf("ptr1的值（即value的地址）: %p\n", (void*)ptr1);
    printf("ptr2的值（即ptr1的地址）: %p\n", (void*)ptr2);
    printf("ptr3的值（即ptr2的地址）: %p\n", (void*)ptr3);

    return 0;
}

运行结果：

复制代码 
变量value的值: 100
通过一级指针访问: 100
通过二级指针访问: 100
通过三级指针访问: 100

地址信息:
value的地址: 0x7ffeefbff5cc
ptr1的值（即value的地址）: 0x7ffeefbff5cc
ptr2的值（即ptr1的地址）: 0x7ffeefbff5c0
ptr3的值（即ptr2的地址）: 0x7ffeefbff5b8

多级指针的理解：

  • 一级指针：存储普通变量的地址
  • 二级指针：存储一级指针的地址
  • 三级指针：存储二级指针的地址
  • 以此类推...

2. 多级指针与动态二维数组

多级指针最常见的应用之一是动态分配多维数组。

c 复制代码 
#include <stdio.h>
#include <stdlib.h>

int main() {
    int rows = 3, cols = 4;
    int **array; // 二级指针

    // 分配行指针数组
    array = (int**)malloc(rows * sizeof(int*));
    if (array == NULL) {
        printf("内存分配失败！\n");
        return 1;
    }

    // 为每一行分配列数组
    for (int i = 0; i < rows; i++) {
        array[i] = (int*)malloc(cols * sizeof(int));
        if (array[i] == NULL) {
            printf("内存分配失败！\n");
            return 1;
        }
    }

    // 初始化并打印二维数组
    printf("动态二维数组：\n");
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            array[i][j] = i * cols + j;
            printf("%2d ", array[i][j]);
        }
        printf("\n");
    }

    // 释放内存
    for (int i = 0; i < rows; i++) {
        free(array[i]);
    }
    free(array);

    return 0;
}

3. 多级指针在函数参数中的应用

当我们需要在函数中修改指针的值时，需要传递指针的指针。

c 复制代码 
#include <stdio.h>
#include <stdlib.h>

// 错误的做法：无法修改外部指针
void allocateMemoryWrong(int *ptr, int size) {
    ptr = (int*)malloc(size * sizeof(int));
    if (ptr == NULL) {
        printf("内存分配失败！\n");
        return;
    }
    // 这里ptr是局部变量，函数返回后丢失
}

// 正确的做法：使用二级指针
void allocateMemoryCorrect(int **ptr, int size) {
    *ptr = (int*)malloc(size * sizeof(int));
    if (*ptr == NULL) {
        printf("内存分配失败！\n");
        return;
    }
}

// 初始化数组
void initArray(int *arr, int size, int value) {
    for (int i = 0; i < size; i++) {
        arr[i] = value + i;
    }
}

// 打印数组
void printArray(int *arr, int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

int main() {
    int *array = NULL;
    int size = 5;

    printf("多级指针在函数参数中的应用：\n");

    // 错误示例
    allocateMemoryWrong(array, size);
    if (array == NULL) {
        printf("错误示例：array仍然是NULL\n");
    }

    // 正确示例
    allocateMemoryCorrect(&array, size);
    if (array != NULL) {
        initArray(array, size, 10);
        printf("正确示例：array已分配并初始化: ");
        printArray(array, size);
        free(array);
    }

    return 0;
}

第二部分：函数指针

1. 函数指针的基本概念

函数指针是指向函数的指针，可以像普通函数一样调用。

c 复制代码 
#include <stdio.h>

// 简单的数学函数
int add(int a, int b) {
    return a + b;
}

int subtract(int a, int b) {
    return a - b;
}

int multiply(int a, int b) {
    return a * b;
}

int divide(int a, int b) {
    if (b != 0) return a / b;
    return 0;
}

int main() {
    // 声明函数指针
    int (*operation)(int, int);

    int x = 10, y = 5;

    // 让函数指针指向add函数
    operation = add;
    printf("%d + %d = %d\n", x, y, operation(x, y));

    // 指向subtract函数
    operation = subtract;
    printf("%d - %d = %d\n", x, y, operation(x, y));

    // 指向multiply函数
    operation = multiply;
    printf("%d * %d = %d\n", x, y, operation(x, y));

    // 指向divide函数
    operation = divide;
    printf("%d / %d = %d\n", x, y, operation(x, y));

    return 0;
}

函数指针的声明：

c 复制代码 
返回值类型 (*指针变量名)(参数类型1, 参数类型2, ...);

2. 函数指针数组

函数指针数组可以用于实现类似"命令模式"的功能。

c 复制代码 
#include <stdio.h>

// 数学运算函数
double add(double a, double b) { return a + b; }
double subtract(double a, double b) { return a - b; }
double multiply(double a, double b) { return a * b; }
double divide(double a, double b) { 
    if (b != 0) return a / b;
    printf("错误：除零！\n");
    return 0;
}

int main() {
    // 声明函数指针数组
    double (*operations[4])(double, double) = {add, subtract, multiply, divide};
    char *operation_names[] = {"加法", "减法", "乘法", "除法"};

    double x = 10.0, y = 4.0;

    printf("函数指针数组示例：\n");
    for (int i = 0; i < 4; i++) {
        double result = operations[i](x, y);
        printf("%s: %.2f %c %.2f = %.2f\n", 
               operation_names[i], x, 
               (i == 0 ? '+' : (i == 1 ? '-' : (i == 2 ? '*' : '/'))), 
               y, result);
    }

    return 0;
}

3. 回调函数

函数指针最常见的应用是实现回调函数。

c 复制代码 
#include <stdio.h>
#include <stdlib.h>

// 回调函数类型定义
typedef int (*CompareFunction)(int, int);

// 升序比较
int ascending(int a, int b) {
    return a - b;
}

// 降序比较
int descending(int a, int b) {
    return b - a;
}

// 冒泡排序，使用回调函数决定排序顺序
void bubbleSort(int *array, int size, CompareFunction compare) {
    for (int i = 0; i < size - 1; i++) {
        for (int j = 0; j < size - i - 1; j++) {
            if (compare(array[j], array[j + 1]) > 0) {
                // 交换
                int temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }
}

// 打印数组
void printArray(int *array, int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", array[i]);
    }
    printf("\n");
}

int main() {
    int numbers[] = {5, 2, 8, 1, 9, 3};
    int size = sizeof(numbers) / sizeof(numbers[0]);

    printf("原始数组: ");
    printArray(numbers, size);

    // 使用升序排序
    bubbleSort(numbers, size, ascending);
    printf("升序排序: ");
    printArray(numbers, size);

    // 使用降序排序
    bubbleSort(numbers, size, descending);
    printf("降序排序: ");
    printArray(numbers, size);

    return 0;
}

4. 函数指针与qsort函数

C标准库中的qsort函数是使用函数指针的经典例子。

c 复制代码 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 比较函数，用于整型数组排序（升序）
int compareInt(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

// 比较函数，用于整型数组排序（降序）
int compareIntDesc(const void *a, const void *b) {
    return (*(int*)b - *(int*)a);
}

// 比较函数，用于字符串数组排序
int compareString(const void *a, const void *b) {
    return strcmp(*(const char**)a, *(const char**)b);
}

int main() {
    // 整型数组排序
    int numbers[] = {5, 2, 8, 1, 9, 3};
    int numSize = sizeof(numbers) / sizeof(numbers[0]);

    printf("整型数组排序：\n");
    printf("排序前: ");
    for (int i = 0; i < numSize; i++) {
        printf("%d ", numbers[i]);
    }
    printf("\n");

    qsort(numbers, numSize, sizeof(int), compareInt);
    printf("升序排序: ");
    for (int i = 0; i < numSize; i++) {
        printf("%d ", numbers[i]);
    }
    printf("\n");

    qsort(numbers, numSize, sizeof(int), compareIntDesc);
    printf("降序排序: ");
    for (int i = 0; i < numSize; i++) {
        printf("%d ", numbers[i]);
    }
    printf("\n\n");

    // 字符串数组排序
    const char *fruits[] = {"apple", "orange", "banana", "grape", "pear"};
    int fruitSize = sizeof(fruits) / sizeof(fruits[0]);

    printf("字符串数组排序：\n");
    printf("排序前: ");
    for (int i = 0; i < fruitSize; i++) {
        printf("%s ", fruits[i]);
    }
    printf("\n");

    qsort(fruits, fruitSize, sizeof(char*), compareString);
    printf("排序后: ");
    for (int i = 0; i < fruitSize; i++) {
        printf("%s ", fruits[i]);
    }
    printf("\n");

    return 0;
}

第三部分：总结

1. 多级指针要点回顾

多级指针是C语言中强大的工具，主要用于处理指针的指针。二级指针指向一级指针的地址，三级指针指向二级指针的地址，以此类推。多级指针最常见的应用包括动态分配多维数组和在函数中修改指针参数。当我们需要在函数内部改变外部指针的指向时，必须传递指针的地址，也就是使用多级指针。

2. 函数指针要点回顾

函数指针是指向函数的指针变量，它存储的是函数的入口地址。通过函数指针，我们可以在运行时动态选择要调用的函数，这为程序提供了极大的灵活性。函数指针的声明需要指定返回类型和参数类型，使用typedef可以简化复杂的函数指针类型声明。函数指针广泛应用于回调函数、抽象接口和命令模式等场景。

3. 使用场景对比

多级指针的使用场景：

  • 动态多维数组
  • 在函数中修改指针参数
  • 复杂的数据结构（如树、图的邻接表）

函数指针的使用场景：

  • 回调函数
  • 抽象编程接口
  • 命令模式实现
  • 排序和搜索算法的自定义比较

第四部分：常见问题解答

Q1：多级指针最多可以有多少级？

A1：理论上没有限制，但实际编程中很少超过三级。级数太多会降低代码可读性。

Q2：函数指针和普通指针有什么区别？

A2：函数指针指向代码段，普通指针指向数据段。对函数指针进行算术运算是未定义行为。

Q3：为什么需要函数指针？直接调用函数不行吗？

A3：函数指针提供了运行时动态选择函数的能力，增加了程序的灵活性，可以实现回调、插件系统等高级功能。

Q4：如何定义函数指针类型？

A4：可以使用typedef简化函数指针类型定义：

c 复制代码 
typedef int (*CompareFunc)(int, int);
CompareFunc ptr = add; // 现在ptr是函数指针变量

Q5：多级指针在内存中如何表示？

A5：多级指针本身存储在栈或堆中，它指向的指针可能存储在栈、堆或数据段中，最终指向目标数据。

Q6：函数指针可以指向不同类型的函数吗？

A6：不可以。函数指针必须与目标函数的返回类型和参数类型完全匹配。

Q7：如何检查函数指针是否为空？

A7：可以与NULL比较：

c 复制代码 
if (functionPtr != NULL) {
    functionPtr();
}

Q8：多级指针和指针数组有什么关系？

A8：多级指针可以指向指针数组的首元素。例如，int **ptr可以指向int *arr[]数组。

觉得文章有帮助？别忘了：

· 点赞 👍 - 给我一点鼓励

· 收藏 ⭐ - 方便以后查看

· 关注 🔔 - 获取更新通知

标签： #C语言指针 #多级指针 #函数指针 #高级编程

相关推荐
Sunhen_Qiletian2 小时前
YOLOv2算法详解（下篇）：细节打磨与性能突破的终极密码
算法·yolo
wefg14 小时前
【数据结构】unordered 系列容器底层结构和封装
数据结构·算法·哈希算法
从零点4 小时前
插补算法（逐点比较法）+PWM配置操作
算法
DARLING Zero two♡4 小时前
【优选算法】LinkedList-Concatenate：链表的算法之契
数据结构·c++·算法·链表
Moonbit4 小时前
MoonBit Pearls Vol.14：哈希表避坑指南
后端·算法·编程语言
杰克尼5 小时前
120. 三角形最小路径和
算法
树在风中摇曳5 小时前
C语言动态内存管理：从基础到进阶的完整解析
c语言·开发语言·算法
mjhcsp5 小时前
C++ 高精度计算：突破数据类型限制的实现与应用
开发语言·c++·算法·高精度
热门推荐
01GitHub 镜像站点02UV安装并设置国内源03综合整理：pdf预览显示：你尝试预览的文件可能对你的计算机有害。如果你信任此文件以及其来源，请打开此文件以看其内容，如何解决以正常预览文件04Linux下V2Ray安装配置指南05安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）06Labelme从安装到标注：零基础完整指南07BongoCat - 跨平台键盘猫动画工具08《大数据技术原理与应用》实验报告三 熟悉HBase常用操作09看了下昨日泄露的苹果 App Store 源码……10NVIDIA显卡驱动、CUDA、cuDNN 和 TensorRT 版本匹配指南