C 语言指针数组

2025 年 5 月 13 日 | 阅读 11 分钟

引言

C 语言中的指针数组为我们提供了解决方案，可以轻松地分解复杂的数据结构，例如字符串数组和动态数组。与其在数组中存储值，不如数组存储指向其他值或保留内存空间的指向。这有助于我们更好地管理内存，同时减少代码运行时间。

定义问题

假设我们正在尝试将一些字符串放入我们的程序中。一个简单的方法是实现一个二维字符数组。然而，由于字符串长度不同，它们将是一个问题，这导致二维数组内的空间使用效率低下。

使用字符指针数组会更有效。每个指针保存一个指向字符串或已保留内存的地址。了解这一点有助于节省内存，并使字符串调整更加简单。

指针数组的解释

它是一个指针数组，其中存储在元素中的每个地址都指向另一个内存集或变量。就字符串而言，它是一个数组，其中每个元素都保存其对应字符串的地址。

示例 1：将字符串添加到指针数组

 
#include <stdio.h>

int main() {
    // Array of pointers to string literals
    char *names[] = {"Alice", "Bob", "Charlie", "David"};

    // Printing each string
    for (int i = 0; i < 4; i++) {
        printf("%s\n", names[i]);
    }

    return 0;
}   

输出

 
Alice
Bob
Charlie
David

说明

char *names[] 是一个字符串数组，其中每个指针指向字符串常量的第一个字符。
循环遍历数据结构中的字符串并输出其中的每个字符串。
指针数组的优点
1. 内存效率：与固定大小的二维数组不同，没有浪费空间。
2. 灵活性：字符串可以随时分配和调整大小。
3. 更快的访问：指针直接保存内存地址。阐述

示例 2

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

#define MAX_STRINGS 5  // Define the number of strings to store
#define MAX_LENGTH 100 // Define the maximum length of each string

int main() {
    char *strArray[MAX_STRINGS]; // Array of pointers to store string addresses
    int i;

    // Taking input from user
    printf("Enter %d strings:\n", MAX_STRINGS);
    for (i = 0; i < MAX_STRINGS; i++) {
        char temp[MAX_LENGTH]; // Temporary buffer to hold input string

        printf("String %d: ", i + 1);
        fgets(temp, MAX_LENGTH, stdin); // Read user input
        temp[strcspn(temp, "\n")] = 0;  // Remove newline character

        // Allocate memory dynamically for each string
        strArray[i] = (char *)malloc(strlen(temp) + 1);
        if (strArray[i] == NULL) {
            printf("Memory allocation failed!\n");
            return 1;
        }
        
        // Copy input string to allocated memory
        strcpy(strArray[i], temp);
    }

    // Displaying stored strings
    printf("\nStored Strings:\n");
    for (i = 0; i < MAX_STRINGS; i++) {
        printf("%d: %s\n", i + 1, strArray[i]);
    }

    // Freeing dynamically allocated memory
    for (i = 0; i < MAX_STRINGS; i++) {
        free(strArray[i]);
    }

    return 0;
}   

输出

 
Enter 5 strings:
String 1: Hello
String 2: World
String 3: Dynamic
String 4: Memory
String 5: Allocation

Stored Strings:
1: Hello
2: World
3: Dynamic
4: Memory
5: Allocation

说明

指针数组
定义 char *strArray[MAX_STRINGS] 以包含字符串的物理地址。
处理用户输入
用户输入存储在名为 temp[MAX_LENGTH] 的临时缓冲区中。
使用 fgets(temp, MAX_LENGTH, stdin) 接收输入。
temp[strcspn(temp, \n)] = 0; 处理换行符。
内存分配
malloc(strlen(temp)+1) 为每个字符串分配所需的精确内存量。
strcpy(strArray[i], temp); 将字符串存储到分配的内存中。
内存管理
使用后，free(strArray[i]) 丢弃分配的内存以防止内存泄漏。

程序 3（优化）

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

#define MAX_STRINGS 5  // Number of strings to store
#define MAX_LENGTH 100 // Maximum length of each string

int main() {
    char *strArray[MAX_STRINGS]; // Array of pointers to store strings

    // Taking input from the user
    printf("Enter %d strings:\n", MAX_STRINGS);
    for (int i = 0; i < MAX_STRINGS; i++) {
        strArray[i] = (char *)malloc(MAX_LENGTH * sizeof(char)); // Allocate memory
        if (strArray[i] == NULL) {
            printf("Memory allocation failed!\n");
            return 1;
        }

        printf("String %d: ", i + 1);
        scanf(" %[^\n]", strArray[i]); // Read input with spaces, avoiding extra buffer
    }

    // Display stored strings
    printf("\nStored Strings:\n");
    for (int i = 0; i < MAX_STRINGS; i++) {
        printf("%d: %s\n", i + 1, strArray[i]);
    }

    // Free allocated memory
    for (int i = 0; i < MAX_STRINGS; i++) {
        free(strArray[i]);
    }

    return 0;
}   

输出

 
Enter 5 strings:
String 1: Hello
String 2: World
String 3: Dynamic
String 4: Memory
String 5: Allocation

Stored Strings:
1: Hello
2: World
3: Dynamic
4: Memory
5: Allocation

C 语言中的指针数组类型

1. 指向整数的指针数组

指向整数的指针数组存储整数变量的内存地址，而不是整数值本身。这使我们能够有效地管理整数数据，而无需复制值。

示例代码

 
#include <stdio.h>

int main() {
    int a = 10, b = 20, c = 30;
    int *arr[3];  // Array of integer pointers

    arr[0] = &a;
    arr[1] = &b;
    arr[2] = &c;

    // Printing values using pointers
    for (int i = 0; i < 3; i++) {
        printf("Value at arr[%d]: %d\n", i, *arr[i]);
    }

    return 0;
}   

输出

 
Value at arr[0]: 10
Value at arr[1]: 20
Value at arr[2]: 30

2. 指向浮点数的指针数组

指向浮点数的指针数组存储浮点变量的地址，从而在科学计算、金融应用和统计中实现对十进制值的动态处理。

示例代码

 
#include <stdio.h>

int main() {
    float a = 3.14, b = 2.71, c = 9.81;
    float *arr[3];  // Array of float pointers

    arr[0] = &a;
    arr[1] = &b;
    arr[2] = &c;

    // Printing values
    for (int i = 0; i < 3; i++) {
        printf("Value at arr[%d]: %.2f\n", i, *arr[i]);
    }

    return 0;
}   

输出

 
Value at arr[0]: 3.14  
Value at arr[1]: 2.71  
Value at arr[2]: 9.81

3. 指向字符串的指针数组

指向字符串的指针数组对于动态存储和操作多个字符串很有用，而不会浪费内存。数组中的每个指针都指向一个字符串文字或动态分配的字符串。

示例代码

 
#include <stdio.h>

int main() {
    char *names[] = {"Alice", "Bob", "Charlie", "David"};  // Array of string pointers

    // Printing strings
    for (int i = 0; i < 4; i++) {
        printf("Name[%d]: %s\n", i, names[i]);
    }

    return 0;
}   

输出

 
Name[0]: Alice
Name[1]: Bob
Name[2]: Charlie
Name[3]: David

4. 指向结构的指针数组

我们不直接存储结构数组，而是使用指向结构的指针数组，从而可以动态分配内存并有效地处理复杂数据。

示例代码

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

struct Student {
    char name[50];
    int age;
};

int main() {
    struct Student *students[3];  // Array of pointers to structures

    // Allocating memory dynamically
    for (int i = 0; i < 3; i++) {
        students[i] = (struct Student *)malloc(sizeof(struct Student));
        printf("Enter name and age for student %d: ", i + 1);
        scanf("%s %d", students[i]->name, &students[i]->age);
    }

    // Printing student details
    printf("\nStudent Details:\n");
    for (int i = 0; i < 3; i++) {
        printf("Name: %s, Age: %d\n", students[i]->name, students[i]->age);
        free(students[i]); // Free allocated memory
    }

    return 0;
}   

输出

 
Enter name and age for student 1: John 20
Enter name and age for student 2: Alice 22
Enter name and age for student 3: Bob 19
Student Details:
Name: John, Age: 20
Name: Alice, Age: 22
Name: Bob, Age: 19

5. 指向数组的指针数组（数组的指针）

此类型存储整个数组的地址，从而可以有效地管理矩阵等二维数据。

示例代码

 
#include <stdio.h>

int main() {
    int arr1[] = {1, 2, 3};
    int arr2[] = {4, 5, 6};
    int arr3[] = {7, 8, 9};

    int *arr[] = {arr1, arr2, arr3};  // Array of pointers to arrays

    // Printing 2D data using pointers
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            printf("%d ", arr[i][j]);
        }
        printf("\n");
    }

    return 0;
}   

输出

6. 指向指针的指针数组（指针的指针）

它对于处理多级动态分配很有用，例如动态分配的二维数组。

示例

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

int main() {
    int rows = 3, cols = 3;
    int **matrix;

    // Allocating memory for rows
    matrix = (int **)malloc(rows * sizeof(int *));
    for (int i = 0; i < rows; i++) {
        matrix[i] = (int *)malloc(cols * sizeof(int));  // Allocating columns
    }

    // Initializing values
    int count = 1;
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            matrix[i][j] = count++;
        }
    }

    // Printing matrix
    printf("Matrix:\n");
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }

    // Freeing memory
    for (int i = 0; i < rows; i++) {
        free(matrix[i]);
    }
    free(matrix);

    return 0;
}   

输出

 
Matrix:  
1 2 3  
4 5 6  
7 8 9

C 语言中指针数组的优点

1. 节省内存

一个传统的二维数组，每个单元格的尺寸为 n*m，会为每个单独的组件预留特定内存，而不考虑使用了多少组件。
使用指针数组，内存会根据需要进行特定分配，从而减少了不必要的资源使用。

2. 快速访问

使用指针进行数据访问比执行索引快得多，因为指针直接预留了特定的内存区域。
这最适用于需要快速数据访问的情况，例如函数指针表。

3. 内存分配管理

指针与静态数组不同，因为它们允许在程序执行期间进行内存的释放和分配；这是通过 malloc() 和 realloc() 实现的。
这使得能够动态地更改可以处理的数据量，这在处理用户输入或文件数据时尤其有用。

4. 不同大小的数据存储

对于某些程序，例如需要文本处理的程序，二维字符数组在有效存储不同长度的字符串方面会遇到困难。
每个字符串将占用内存中所需的空间，从而减少了内存消耗。

5. 函数指针数组用法：处理灵活的函数

由于它们被存储为函数指针，不同的条件可能导致从指针数组执行不同的函数。
它在操作系统和嵌入式系统中的回调实现和函数分派表中找到了广泛的应用。

6. 有助于排序算法

移动整个行成本很高，这可能是二维数组排序效率低下的原因。
交换指针比交换整个数组成本低。因此，排序在时间和空间方面变得更简单、成本更低。

7. 使多级数据结构更容易

通过指针实现并有效地处理链表、树、图和哈希表的复杂结构，以便于访问和导航。
与邻接矩阵相比，图算法的邻接表通常使用指针数组，因为占用的空间更少。

C 语言中指针数组的应用

1. 管理字符串和文本

在聊天程序、文本编辑器和搜索引擎中，需要一种灵活的存储文本的方式，此时它很有用。
它有助于以简洁有效的方式存储多个句子或单词。

2. 命令行参数 (argv[])

作为指针数组的一部分，main 函数的 argv[] 参数提供了灵活性 - C 程序可以处理从命令行传递给程序的参数。
在自动化工具、编译器和 shell 脚本中很有用。

3. 函数指针和响应调用机制

在由事件驱动的程序中，如 GUI 应用程序和设备驱动程序，回调函数对于操作系统中断处理是必需的。
函数指针数组可以用于提供最优的决策制定，而不是使用 switch 或多个 if-else 语句来处理函数选择。

4. 链表、树和图等数据结构，这些被认为是动态的。

为了在链表中删除或插入新节点，会创建一个新节点，该节点具有指向下一个节点的指针，从而使处理过程高效。
为了连接子节点，二叉树和 AVL 树使用指针。
与邻接矩阵相比，使用带指针数组的邻接表的图占用的内存更少。

5. 以动态方式搜索和排序用于简化文件的信息。

使用指针数组存储归并排序和快速排序等大型数据集，可减少内存操作。
一种指针风格的方法，其中仅对字符串数组的指针进行排序而不是对整个字符串进行排序，是一个简单排序的例子。

6. 内存和文件管理数据库系统是文件指针。

在系统中，数据库系统使用它来索引文件数据并高效检索文件。
数据库使用数组中存储的指针将报告记录加载到内存块中，这是一种动态处理查询结果的方法。

7. 嵌入式系统和适当的操作系统动态内存分配。

分页和堆管理是两种用于系统控制以恢复数据的操作系统内存恢复感知方法。
为了在内存空间有限的嵌入式系统中有效处理传感器数据，嵌入式系统中的指针是（有用的）。

8. AST 或抽象语法块可以通过编译器得到有效控制。

在编译器中，可以通过附加指针来有效控制 ASP，以方便函数对其进行跟踪。
指针出现在符号表中或与主要语言关联，以帮助变量有效管理加载的问题函数。

C 语言中指针数组的缺点

1. 复杂性增加

管理指针数组需要对内存分配、去分配和指针操作有深入的理解。
错误，如解引用空指针或忘记分配内存，可能导致运行时错误。

2. 内存泄漏风险较高

由于内存是使用 malloc() 动态分配的，因此必须使用 free() 显式释放。
忘记释放() 分配的内存会导致内存泄漏，从而随着时间的推移使程序变慢。

3. 调试更难

调试与指针相关的错误（如悬空指针、段错误和无效内存访问）非常困难。
与数组不同，数组的索引错误更容易跟踪，而与指针相关的错误可能更难检测和修复。

4. 内存管理的 CPU 开销更高

每次动态分配（malloc() 或 realloc()）都涉及与系统内存管理器的交互，这会增加 CPU 开销。
在固定大小内存有效的情况下（例如静态二维数组），动态分配可能成本过高。

5. 对缓存不友好

常规数组将元素存储在连续的内存位置，由于缓存局部性，CPU 可以更快地获取数据。
指针数组存储指向不同内存位置的地址，这会导致缓存未命中，并可能导致性能下降。

结论

总之，C 语言中的指针数组对于高效处理动态数据结构非常有用。它们在内存管理方面提供了灵活性，尤其是在处理字符串或可变长度数据时。理解这个概念可以提高 C 程序的效率和性能。

下一个主题C-program-to-find-the-largest-element-in-an-array-using-pointers

← 上一个下一个 →

C 语言指针数组

引言

定义问题

指针数组的解释

示例 1：将字符串添加到指针数组

说明

示例 2

说明

程序 3（优化）

C 语言中的指针数组类型

1. 指向整数的指针数组

示例代码

2. 指向浮点数的指针数组

示例代码

3. 指向字符串的指针数组

示例代码

4. 指向结构的指针数组

示例代码

5. 指向数组的指针数组（数组的指针）

示例代码

6. 指向指针的指针数组（指针的指针）

示例

C 语言中指针数组的优点

C 语言中指针数组的应用

C 语言中指针数组的缺点

结论

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

C 语言教程

C 语言控制语句

C 语言函数

C 语言数组

C 语言指针

C 语言动态内存

C 语言字符串

C 语言数学

C 语言结构体和联合体

C 语言文件处理

C 语言预处理器

C 语言命令行

C 语言程序

C 语言面试

选择题

C 语言编程测试

C 语言基础测试

C 语言控制语句测试

C 语言函数测试

C 语言数组测试

C 语言指针测试

C 语言字符串测试

C 语言结构体测试

C 语言预处理器测试

数学

C 语言杂项

C 语言指针数组

引言

定义问题

指针数组的解释

示例 1：将字符串添加到指针数组

说明

示例 2

说明

程序 3（优化）

C 语言中的指针数组类型

1. 指向整数的指针数组

示例代码

2. 指向浮点数的指针数组

示例代码

3. 指向字符串的指针数组

示例代码

4. 指向结构的指针数组

示例代码

5. 指向数组的指针数组（数组的指针）

示例代码

6. 指向指针的指针数组（指针的指针）

示例

C 语言中指针数组的优点

C 语言中指针数组的应用

C 语言中指针数组的缺点

结论

相关帖子

C 语言 malloc(), calloc(), realloc() 函数的区别

C 语言恐龙游戏

C 语言前缀自增和前缀自减的区别

C 语言静态库和共享库的区别

C 语言按地址调用

C 语言和 Fortran 的区别

C 语言 Popen() 函数