如何在C中创建一个包含静态数组的动态数组？

我的程序解析代码，当它解析代码时，我需要跟踪每x行（可能每10行左右）它通过每个关键字的多少个实例，我计划稍后用gnuplot创建一个直方图，但这并不重要

所以有13个关键字，我可以用一个0的数组轻松地统计它们，其中每个索引代表一个关键字，每当我找到一个关键字，我就会将它的索引增加1。好简单

int keywordcount[13]={0};

问题是我需要每10行创建一个新的

keywordcount

，我不知道文件有多少代码行。这告诉我应该有一个动态数组

keywordcount

数组

---

如何在C中声明这个数组的动态数组，以及如何向其中添加

keywordcount

数组？我仍然对C中的多维数组感到困惑。我不知道是否应该将它声明为指针数组或什么，我不知道如何为它分配一个新的

keywordcount

数组，该数组在创建

keywordcount

的函数返回时不会消失。如果有不清楚的地方，请告诉我。

假设将创建多少

关键字计数。比如说，你几乎可以肯定其中有10个会被创建

可以动态声明一个包含10行13列的二维数组

现在，
keywordcount[0]
将是第一个keywordcount数组（大小为13）的索引，依此类推

现在，如果在实际操作中发现需要10个以上的关键字计数数组，可以使用动态增加2D数组的大小


PS：一个很好的建议是，每次需要增加2D数组的大小时，将其行大小增加一倍（而不是每次增加一行，这样可以避免重新定位，这在某些情况下可能会损害性能）。
您可以使用
malloc（）
或
calloc（）
创建静态数组的动态数组。例如，这将
keywordcount\u arr
定义为指向13个
int
s数组的指针（这里为
max\u行
这样的数组分配了足够的内存）：

如果在此处使用
typedef
，可能会使代码更易于阅读和写入：

typedef int KW_Count[13];

/* ... */

KW_Count *keywordcount_arr = calloc(max_lines, sizeof *keywordcount_arr);

可以使用二维数组索引将索引编入分配的内存：

for (size_t i = 0; i < 13; i++) {
    keywordcount_arr[0][i] = i;
}

以下是一个示例程序：

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

#define NUM_KEYWORDS  13

typedef int KW_Count[NUM_KEYWORDS];

int main(void)
{
    size_t max_lines = 10;
    size_t num_lines = 0;
    KW_Count *keywordcount_arr = calloc(max_lines, sizeof *keywordcount_arr);
    if (keywordcount_arr == NULL) {
        perror("Allocation failure");
        /* Handle error... perhaps: */
        exit(EXIT_FAILURE);
    }

    /* Store keyword counts directly in keywordcount_arr[] */
    ++num_lines;
    for (size_t i = 0; i < NUM_KEYWORDS; i++) {
        keywordcount_arr[0][i] = i;
    }

    /* Or use memcpy() if an existing array must be stored */
    ++num_lines;
    KW_Count keywordcount = { 0, 2, 0, 0, 3, 1, 0, 0, 0, 1, 2, 0, 1 };
    memcpy(keywordcount_arr[1],
           keywordcount,
           sizeof *keywordcount * NUM_KEYWORDS);

    /* Use realloc() to grow the dynamic array as needed */
    max_lines *= 2;
    KW_Count *temp = realloc(keywordcount_arr,
                             sizeof *keywordcount_arr * max_lines);
    if (temp == NULL) {
        perror("Unable to reallocate");
        /* Handle error */
    } else {
        keywordcount_arr = temp;
    }

    /* Use realloc() to trim the dynamic array to final size */
    temp = realloc(keywordcount_arr, sizeof *keywordcount_arr * num_lines);
    if (temp == NULL) {
        perror("Unable to reallocate");
        /* Handle error */
    } else {
        keywordcount_arr = temp;
    }

    /* Display array contents */
    for (size_t i = 0; i < num_lines; i++) {
        for (size_t j = 0; j < NUM_KEYWORDS; j++) {
            printf("%5d", keywordcount_arr[i][j]);
        }
        putchar('\n');
    }

    /* Cleanup */
    free(keywordcount_arr);

    return 0;
}

不要触摸2D数组、数组数组、指针数组、指向数组的指针或任何类似的废话

将静态大小的数组包装在结构中

typedef struct
{
  int keyword_count[13];
} fragment_info;

像创建任何其他动态数组一样，创建一个动态数组
fragment\u info
：

fragment_info* infos = malloc(initial_capacity * sizeof(*infos));
....
fragment_info* new_infos = realloc(infos, new_capacity * sizeof(*new_infos));

现在，如果您想存储关于10行片段的附加信息，您可以在一个自然的位置保存它。只需在
结构中添加更多字段
使用typedef声明13字节数组类型，然后在这种类型的数组上使用realloc。不，不能在声明为
int关键字计数[10][13]的数组上使用realloc（）。为了使用这种方法，您必须从一开始就动态地分配它。
typedef struct
{
  int keyword_count[13];
} fragment_info;

fragment_info* infos = malloc(initial_capacity * sizeof(*infos));
....
fragment_info* new_infos = realloc(infos, new_capacity * sizeof(*new_infos));