Question

我在文件范围内有二维数组内部结构。该结构被传递给几个函数。我需要分配这个数组来匹配[LINES] [COLS]。如果终端调整大小，我还需要重新分配它。实现这个的最佳方法是什么？

我发现我应该在结构中使用指针而不是数组。但是我在分配应该代表二维数组的指针时遇到了问题。

原始结构：

struct data {
    // KB/s
    float rxs;
    float txs;
    // peak KB/s
    float rxmax;
    float txmax;
    float max;
    float max2;
    // total traffic
    int rx;
    int tx;
    int rx2;
    int tx2;
    // packets
    int rxp;
    int txp;
    // bandwidth graph
    float rxgraphs[LEN];
    float txgraphs[LEN];
    bool rxgraph[GRAPHLEN][LEN];
    bool txgraph[GRAPHLEN][LEN];
};

指针版本不起作用：

struct data {
    // KB/s
    double rxs;
    double txs;
    // peak KB/s
    double rxmax;
    double txmax;
    double max;
    double max2;
    // total traffic
    long rx;
    long tx;
    long rx2;
    long tx2;
    // packets
    long rxp;
    long txp;
    // bandwidth graph
    double *rxgraphs;
    double *txgraphs;
    bool **rxgraph;
    bool **txgraph;
};

int main(int argc, char *argv[]) {
    struct data d = {.rxs = 0, .txs = 0};
    d.rxgraphs = malloc(COLS * sizeof(double));
    d.txgraphs = malloc(COLS * sizeof(double));
    d.rxgraph = malloc((LINES/2) * COLS * sizeof(bool));
    d.txgraph = malloc((LINES/2) * COLS * sizeof(bool));

Answer 1

您可以使用以下函数从指针数组初始化二维数组：

int **array_calloc (int rows, int cols)
{
    register int i;
    float **array = malloc (rows * sizeof (*array));

    for (i = 0; i < rows; i++)
    {
        array [i] = calloc (cols, sizeof (**array));
    }
    return array;
}

malloc用于指向指针数组的指针，calloc用于将值初始化为0的指针数组。以上是整数的一般情况，但您可以适应bool。适应bool之后你可以做到：

d.rxgraph = array_calloc (rows, cols);
d.txgraph = array_calloc (rows, cols);

完成后，您有责任释放d.rxgraph和d.txgraph。

动态分配2维数组以匹配LINES和COLS

1 个答案: