C语言中如何无需指定位置添加数组元素？是否有类似Python append的方法

Great question! Let's break this down clearly, since C handles arrays very differently from Python's dynamic lists.

First, a critical point to remember: Native C arrays are static—once you declare their size (like int array[100]), that size is fixed at compile time. There’s no built-in "append" feature that automatically resizes the array for you, unlike Python’s list.append() which handles dynamic resizing under the hood.

But you can absolutely replicate Python-like append behavior in C by using dynamic memory allocation. Here are two practical approaches:

1. Manual dynamic array with malloc and realloc #

Use a pointer instead of a fixed-size array, track the current number of elements, and resize the allocated memory when you run out of space with realloc:

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

int main() {
    int *dynamic_arr = NULL;
    int current_size = 0;    // Number of elements currently stored
    int allocated_capacity = 0;  // Total space allocated

    int input_value;
    printf("Enter numbers to add (type -1 to stop):\n");
    while (scanf("%d", &input_value) == 1 && input_value != -1) {
        // Resize if we've filled the current allocated space
        if (current_size >= allocated_capacity) {
            // Start with 4 elements, double capacity each time we need more space
            int new_capacity = (allocated_capacity == 0) ? 4 : allocated_capacity * 2;
            int *temp_ptr = realloc(dynamic_arr, new_capacity * sizeof(int));
            
            // Always check if realloc succeeded (returns NULL on failure)
            if (temp_ptr == NULL) {
                perror("Failed to resize array");
                free(dynamic_arr); // Clean up existing memory before exiting
                return 1;
            }
            dynamic_arr = temp_ptr;
            allocated_capacity = new_capacity;
        }

        // Add the new element to the "end" of the array
        dynamic_arr[current_size++] = input_value;
    }

    // Print the final array
    printf("\nYour array contains %d elements:\n", current_size);
    for (int i = 0; i < current_size; i++) {
        printf("%d ", dynamic_arr[i]);
    }
    printf("\n");

    // Don't forget to free dynamically allocated memory!
    free(dynamic_arr);
    return 0;
}

2. Encapsulate into a struct for cleaner, Python-like usage #

To make this feel even more intuitive, wrap the pointer, size, and capacity into a struct, then write a dedicated append function for it:

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

// Struct to hold our dynamic array's state
typedef struct {
    int *data;
    int size;       // Current number of elements
    int capacity;   // Total allocated space
} DynamicArray;

// Initialize an empty dynamic array
void init_dynamic_array(DynamicArray *arr) {
    arr->data = NULL;
    arr->size = 0;
    arr->capacity = 0;
}

// Append an element (returns 0 on success, -1 on failure)
int append(DynamicArray *arr, int value) {
    if (arr->size >= arr->capacity) {
        int new_capacity = (arr->capacity == 0) ? 4 : arr->capacity * 2;
        int *temp_ptr = realloc(arr->data, new_capacity * sizeof(int));
        
        if (temp_ptr == NULL) {
            return -1;
        }
        arr->data = temp_ptr;
        arr->capacity = new_capacity;
    }
    arr->data[arr->size++] = value;
    return 0;
}

// Free memory used by the dynamic array
void free_dynamic_array(DynamicArray *arr) {
    free(arr->data);
    arr->data = NULL;
    arr->size = 0;
    arr->capacity = 0;
}

int main() {
    DynamicArray my_arr;
    init_dynamic_array(&my_arr);

    int input_value;
    printf("Enter numbers to add (type -1 to stop):\n");
    while (scanf("%d", &input_value) == 1 && input_value != -1) {
        if (append(&my_arr, input_value) == -1) {
            perror("Failed to append element");
            free_dynamic_array(&my_arr);
            return 1;
        }
    }

    printf("\nYour array contains %d elements:\n", my_arr.size);
    for (int i = 0; i < my_arr.size; i++) {
        printf("%d ", my_arr.data[i]);
    }
    printf("\n");

    free_dynamic_array(&my_arr);
    return 0;
}

Key Tips: #

• Always check if realloc returns NULL—this means the resize failed (usually due to insufficient memory), and you should handle this error to avoid crashes.
• Never skip freeing dynamically allocated memory when you’re done with it—this prevents memory leaks.
• The "double capacity" strategy is efficient because it minimizes the number of expensive realloc calls (amortized over many appends, each operation is nearly O(1)).

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