求助：如何为C语言自定义结构体数组分配内存？

Great question—let's break down the two main ways to allocate memory for your user and admin struct arrays in C, since you've already got your struct definitions sorted out.

1. Static/Stack Allocation (The Easy, Fixed-Size Option) #

First off, the code you've already written is actually a form of static allocation! How it works depends on where you declare the arrays:

Global Scope Allocation #

If you declare the arrays outside all functions (in global scope), they'll live in the global storage area—memory is allocated when your program starts, and released automatically when it exits. This is great for arrays that need to be accessible across multiple functions.

Example:

#include <string.h>

// Your struct definitions
typedef struct user { 
    char username[30]; 
    char password[30]; 
    char email[100]; 
    char nome[30]; 
} user; 

typedef struct admin { 
    char nome[30]; 
    char passwd[30]; 
} admin;

// Global array allocation (lives in global storage)
user database[50]; 
user banlist[100]; 
admin list[10]; 

int main() {
    // Use the arrays directly
    strcpy(database[0].username, "john_doe");
    strcpy(list[0].nome, "site_admin");
    return 0;
}

Stack Allocation (Local to a Function) #

If you declare the arrays inside a function (like main()), they'll be allocated on the stack—memory is freed automatically when the function finishes executing. This is simple for small-to-medium sized arrays, but keep in mind: stack space is limited (usually a few MB), so huge arrays here can cause a stack overflow.

Example:

#include <string.h>

typedef struct user { 
    char username[30]; 
    char password[30]; 
    char email[100]; 
    char nome[30]; 
} user; 

typedef struct admin { 
    char nome[30]; 
    char passwd[30]; 
} admin;

int main() {
    // Stack-allocated arrays (freed when main exits)
    user database[50]; 
    user banlist[100]; 
    admin list[10]; 

    strcpy(database[0].username, "jane_smith");
    return 0;
}

2. Dynamic Heap Allocation (Flexible, Resizable Option) #

For larger arrays, or if you need to change the array size at runtime, use heap allocation with malloc() or calloc() (from <stdlib.h>). You'll need to manually free this memory with free() to avoid leaks.

Key Steps: #

1. Calculate total memory needed: number_of_elements * sizeof(struct_type)
2. Check if allocation succeeded (functions return NULL on failure)
3. Use the array like a normal pointer-based array
4. Free the memory when you're done

Example with malloc() and calloc():

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

typedef struct user { 
    char username[30]; 
    char password[30]; 
    char email[100]; 
    char nome[30]; 
} user; 

typedef struct admin { 
    char nome[30]; 
    char passwd[30]; 
} admin;

int main() {
    // Allocate database: 50 user structs
    user *database = malloc(50 * sizeof(user));
    if (database == NULL) {
        fprintf(stderr, "Error: Failed to allocate memory for database\n");
        return 1;
    }

    // Allocate banlist with calloc (initializes all bytes to 0)
    user *banlist = calloc(100, sizeof(user));
    if (banlist == NULL) {
        fprintf(stderr, "Error: Failed to allocate memory for banlist\n");
        free(database); // Clean up already allocated memory
        return 1;
    }

    // Allocate admin list
    admin *list = malloc(10 * sizeof(admin));
    if (list == NULL) {
        fprintf(stderr, "Error: Failed to allocate memory for admin list\n");
        free(database);
        free(banlist);
        return 1;
    }

    // Use the arrays
    strcpy(database[0].username, "dynamic_user");
    strcpy(list[0].passwd, "secure_pass123");

    // Resize database to 100 elements (optional)
    user *resized_database = realloc(database, 100 * sizeof(user));
    if (resized_database != NULL) {
        database = resized_database;
    } else {
        fprintf(stderr, "Warning: Couldn't resize database, keeping original size\n");
    }

    // Free memory in reverse order of allocation (good practice)
    free(list);
    free(banlist);
    free(database);

    return 0;
}

malloc() vs calloc(): #

• malloc(): Allocates raw memory, leaves values uninitialized (random garbage).
• calloc(): Allocates memory and sets all bytes to 0—useful if you need default empty values.

Which Should You Choose? #

• Use static/stack allocation if your array sizes are fixed and small-to-medium. No manual memory management needed.
• Use heap allocation if you need large arrays, resizable arrays, or memory that outlives the function where it's created. Just don't forget to free()!

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