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

C语言——指针进阶应用

article 2025/2/21 2:51:36

引言

在掌握了指针的基础知识后，我们可以进一步探索指针在 C 语言中的高级应用。指针的灵活性和强大功能使其在复杂数据结构、函数指针、动态内存管理等领域大放异彩。本文将深入探讨指针的进阶用法，包括多级指针、函数指针、指针数组、动态内存分配的高级技巧，以及如何避免常见的指针陷阱。通过实际代码示例，帮助你从“会用指针”进阶到“精通指针”。

一、多级指针

1. 二级指针

二级指针是指向指针的指针，常用于动态分配二维数组或修改指针本身的值。

示例：动态分配二维数组

int **arr;
int rows = 3, cols = 4;

// 分配行指针
arr = (int **)malloc(rows * sizeof(int *));
for (int i = 0; i < rows; i++) {
    // 为每行分配列
    arr[i] = (int *)malloc(cols * sizeof(int));
}

// 使用二维数组
arr[1][2] = 10;  // 第2行第3列赋值为10

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

2. 三级指针

三级指针是指向二级指针的指针，常用于动态分配三维数组或更复杂的数据结构。

示例：动态分配三维数组

int ***arr;
int x = 2, y = 3, z = 4;

// 分配第一维
arr = (int ***)malloc(x * sizeof(int **));
for (int i = 0; i < x; i++) {
    // 分配第二维
    arr[i] = (int **)malloc(y * sizeof(int *));
    for (int j = 0; j < y; j++) {
        // 分配第三维
        arr[i][j] = (int *)malloc(z * sizeof(int));
    }
}

// 使用三维数组
arr[1][2][3] = 20;  // 第2层第3行第4列赋值为20

// 释放内存
for (int i = 0; i < x; i++) {
    for (int j = 0; j < y; j++) {
        free(arr[i][j]);
    }
    free(arr[i]);
}
free(arr);

二、函数指针

函数指针是指向函数的指针，常用于回调函数、动态函数调用等场景。

1. 函数指针的声明与使用

#include <stdio.h>

int add(int a, int b) {
    return a + b;
}

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

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

    // 指向 add 函数
    func_ptr = add;
    printf("Add: %d\n", func_ptr(5, 3));  // 输出 8

    // 指向 subtract 函数
    func_ptr = subtract;
    printf("Subtract: %d\n", func_ptr(5, 3));  // 输出 2

    return 0;
}

2. 回调函数

回调函数是通过函数指针实现的，常用于事件驱动编程。

示例：排序算法中的回调

#include <stdio.h>
#include <stdlib.h>

// 回调函数类型
typedef int (*compare_func)(int, int);

// 回调函数：升序比较
int ascending(int a, int b) {
    return a - b;
}

// 回调函数：降序比较
int descending(int a, int b) {
    return b - a;
}

// 通用排序函数
void sort(int *arr, int size, compare_func cmp) {
    for (int i = 0; i < size - 1; i++) {
        for (int j = i + 1; j < size; j++) {
            if (cmp(arr[i], arr[j]) > 0) {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }
}

int main() {
    int arr[] = {5, 2, 9, 1, 5, 6};
    int size = sizeof(arr) / sizeof(arr[0]);

    // 升序排序
    sort(arr, size, ascending);
    printf("Ascending: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    // 降序排序
    sort(arr, size, descending);
    printf("Descending: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}

三、指针数组与数组指针

1. 指针数组

指针数组是元素为指针的数组，常用于存储字符串数组。

示例：字符串数组

char *fruits[] = {"Apple", "Banana", "Cherry"};
for (int i = 0; i < 3; i++) {
    printf("%s\n", fruits[i]);
}

2. 数组指针

数组指针是指向数组的指针，常用于传递多维数组。

示例：传递二维数组

void print_matrix(int (*arr)[3], int rows) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < 3; j++) {
            printf("%d ", arr[i][j]);
        }
        printf("\n");
    }
}

int main() {
    int matrix[2][3] = {{1, 2, 3}, {4, 5, 6}};
    print_matrix(matrix, 2);
    return 0;
}

四、动态内存分配的高级技巧

1. 柔性数组（Flexible Array Member）

柔性数组是结构体中最后一个成员，用于动态分配额外空间。

示例：动态字符串结构

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct flex_string {
    int length;
    char data[];  // 柔性数组
};

int main() {
    char str[] = "Hello, World!";
    int length = strlen(str);

    // 分配内存
    struct flex_string *fs = malloc(sizeof(struct flex_string) + length + 1);
    fs->length = length;
    strcpy(fs->data, str);

    printf("Length: %d\n", fs->length);
    printf("Data: %s\n", fs->data);

    free(fs);
    return 0;
}