结构体中使用多维数组的技术咨询（附未完成C代码）

Let's break down your code and walk through the proper ways to handle multi-dimensional arrays in structs, step by step.

First: Critical Bugs in Your Current Code #

Your code has a fatal undefined behavior right out the gate:

• You declared NeuralNetwork *nn; but never allocated memory for the struct itself. This is a "wild pointer"—it points to a random memory address, so accessing nn->input_rows or any member will almost certainly crash your program.
• The final print loop is truncated (nn->inpu...), which is a typo, but the uninitialized pointer is the real showstopper.
• You also don’t have any error checking for malloc calls, which can fail, and no cleanup code, leading to memory leaks.

Fixed Version of Your Code #

Here’s the corrected code with all these issues addressed, plus proper memory management:

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

typedef struct _NeuralNetwork{
    int input_rows;
    int input_columns;
    double **inputs;
} NeuralNetwork;

// Use int main() instead of void main() for C standard compliance
int main(){
    // First, allocate memory for the NeuralNetwork struct itself
    NeuralNetwork *nn = malloc(sizeof(NeuralNetwork));
    if (nn == NULL) {
        fprintf(stderr, "Failed to allocate memory for neural network struct\n");
        return 1;
    }

    int count;
    int i,j;
    nn->input_rows = 2;
    nn->input_columns = 3;

    // Allocate the array of row pointers
    nn->inputs = malloc(nn->input_rows * sizeof(double *));
    if (nn->inputs == NULL) {
        fprintf(stderr, "Failed to allocate row pointers\n");
        free(nn); // Clean up before exiting
        return 1;
    }

    // Allocate each row's data, with error checking and cleanup
    for (i=0; i<nn->input_rows; i++){
        nn->inputs[i] = malloc(nn->input_columns * sizeof(double));
        if (nn->inputs[i] == NULL) {
            // Free any already allocated rows to avoid leaks
            for (int k=0; k<i; k++) {
                free(nn->inputs[k]);
            }
            free(nn->inputs);
            free(nn);
            fprintf(stderr, "Failed to allocate memory for row %d\n", i);
            return 1;
        }
    }

    // Assign values to the 2D array
    count = 0;
    for (i = 0; i < nn->input_rows ; i++)
        for (j = 0; j < nn->input_columns; j++)
            nn->inputs[i][j] = ++count;

    // Print the values
    printf("Neural Network Inputs:\n");
    for (i = 0; i<nn->input_rows; i++){
        for (j = 0; j<nn->input_columns; j++){
            printf("%.0f ", nn->inputs[i][j]);
        }
        printf("\n");
    }

    // Critical: Clean up all allocated memory to avoid leaks
    for (i=0; i<nn->input_rows; i++){
        free(nn->inputs[i]);
    }
    free(nn->inputs);
    free(nn);

    return 0;
}

Proper Techniques for Multi-Dimensional Arrays in Structs #

Depending on your use case, there are a few better or more appropriate ways to handle this:

1. Dynamic 2D Array (Your Approach, Fixed)

This is what you tried, and it works for variable row/column sizes at runtime. The tradeoff is that the memory isn’t contiguous (each row is a separate allocation), which can hurt cache performance. It also requires nested cleanup.

2. Single Contiguous Allocation (Better Cache Performance)

Instead of using a double pointer, allocate a single block of memory and calculate indices manually. This keeps all data in one contiguous chunk, which is faster for most operations, and only requires one free call:

typedef struct _NeuralNetwork{
    int input_rows;
    int input_columns;
    double *inputs; // Single pointer instead of double pointer
} NeuralNetwork;

// Allocation:
nn->inputs = malloc(nn->input_rows * nn->input_columns * sizeof(double));
// Access element at (i,j):
nn->inputs[i * nn->input_columns + j] = value;

3. Flexible Array Member (C99+)

If you know the array size when you allocate the struct, use a flexible array member. This combines the struct and array into one contiguous memory block:

typedef struct _NeuralNetwork{
    int input_rows;
    int input_columns;
    double inputs[]; // No size specified—flexible member
} NeuralNetwork;

// Allocate struct + array in one go:
NeuralNetwork *nn = malloc(sizeof(NeuralNetwork) + 
                           nn->input_rows * nn->input_columns * sizeof(double));
// Access same as single allocation: nn->inputs[i * nn->input_columns + j]

4. Static Compile-Time Size

If your input dimensions are fixed at compile time, you can declare a static 2D array directly in the struct. This is the simplest but least flexible option:

#define INPUT_ROWS 2
#define INPUT_COLS 3
typedef struct _NeuralNetwork{
    double inputs[INPUT_ROWS][INPUT_COLS];
} NeuralNetwork;

Final Notes #

• Always check if malloc returns NULL—it can fail if your system runs out of memory.
• Always free allocated memory to avoid leaks, especially in long-running programs.
• Choose the array approach based on whether you need runtime flexibility, cache efficiency, or simplicity.

内容的提问来源于stack exchange，提问作者ebeninki