C语言结构体数组填充问题：从C#转C遇内存管理困境

Let's break down the issues in your code step by step and fix them—coming from C#, it's totally normal to trip up on C's manual memory management and strict type rules!

Key Problems in Your Current Code #

1. Mismatched Function Arguments & Pointer Usage
   Your printStructs function expects a pointer to an array of myStruct_t pointers (myStruct_t* myStructs[]), but you're passing &strings (a pointer to a char* array)—these types don't align at all. Also, inside the function, you're using . to access members of myStructs[i], but that's a pointer, so you need -> instead. It's simpler to have the function accept a direct pointer to the myStruct_t array (since arrays decay to pointers in C).

2. Incorrect Assignment of arguments
structs[i].arguments is a char** (a pointer to an array of strings), but you're assigning it strings[i] (a single char* string). This is a type mismatch and won't create the array of arguments you want.

3. Redundant Inner Loop
   The for (int j = 0; j < 4; j++) loop does nothing useful—it just overwrites the same struct's values 4 times. You can completely remove it.

Fixed Code with Explanations #

Here's a corrected version that works, plus options for static vs dynamic memory (since memory management is your pain point):

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

typedef struct {
    int id;
    char** arguments;
} myStruct_t;

// Simplified function: accepts a pointer to the struct array + element count
void printStructs(myStruct_t* myStructs, size_t structCount) {
    for (size_t i = 0; i < structCount; i++) {
        printf("Struct ID: %d\n", myStructs[i].id);
        // Traverse arguments until we hit NULL (safe way to avoid array bounds issues)
        char** currentArg = myStructs[i].arguments;
        while (*currentArg != NULL) {
            printf("  - %s\n", *currentArg);
            currentArg++;
        }
    }
}

int main(int argc, char** argv) {
    // Option 1: Static pre-defined argument arrays (no manual memory cleanup needed)
    char* staticArgs[5][4] = {
        {"fooo", "opt1", "opt2", NULL},
        {"ooof", "optA", "optB", NULL},
        {"wack", "x", "y", "z", NULL}, // Oops, fixed to 4 elements to match others
        {"yeet", NULL},
        {"bruh", "single-opt", NULL}
    };

    myStruct_t structs[5];
    for (int i = 0; i < 5; i++) {
        structs[i].id = i;
        // Point the struct's arguments to the pre-defined static array
        structs[i].arguments = staticArgs[i];
    }

    // Option 2: Dynamic memory allocation (for variable-length arguments)
    // Uncomment this block if you need to create arguments on the fly
    /*
    for (int i = 0; i < 5; i++) {
        structs[i].id = i;
        // Allocate memory for 3 arguments + NULL terminator
        structs[i].arguments = malloc(4 * sizeof(char*));
        if (structs[i].arguments == NULL) {
            perror("Failed to allocate memory");
            exit(EXIT_FAILURE);
        }
        // Use strdup to copy strings (it allocates memory automatically)
        structs[i].arguments[0] = strdup(strings[i]);
        structs[i].arguments[1] = strdup("dynamic-opt");
        structs[i].arguments[2] = strdup("another-opt");
        structs[i].arguments[3] = NULL; // Mark end of array
    }
    */

    // Call the print function with the struct array and its length
    printStructs(structs, 5);

    // If using dynamic memory, don't forget to free it to avoid leaks!
    /*
    for (int i = 0; i < 5; i++) {
        char** arg = structs[i].arguments;
        while (*arg != NULL) {
            free(*arg); // Free each string first
            arg++;
        }
        free(structs[i].arguments); // Free the array of pointers
    }
    */

    return 0;
}

Quick Memory Management Tips for C# Devs #

• Static vs Dynamic: Use static arrays when you know the size upfront (no cleanup needed). Use malloc/calloc when sizes are variable, but always pair them with free.
• strdup is your friend: It copies a string and allocates memory for it in one step—just remember to free the result later.
• NULL terminators: Always end string arrays with NULL so you can safely traverse them without knowing the exact length.

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