使用malloc/realloc调整bignum结构体数组：缩容是否无内存泄漏？

Hey there! Great question about realloc and memory leaks when shrinking a dynamic array of your bignum structs. Let's break this down clearly:

Core Answer #

Using realloc() to shrink your bignum dynamic array does NOT cause memory leaks on its own—but there are important caveats to avoid accidental leaks, and your sample code has a potential risk we need to fix.

Why realloc Shrinking Doesn't Cause Leaks #

When you call realloc(ptr, new_size) with a new_size smaller than the original allocated size:

• The function adjusts the memory block to the new, smaller size.
• It preserves the first new_size bytes of data from the original block.
• The excess memory (the part beyond new_size) is automatically returned to the heap—this memory is no longer allocated to your program, so it doesn't count as a leak.

Critical Pitfall in Your Sample Code #

Your current code has a dangerous flaw: if realloc() fails (returns NULL, which can happen if the system can't adjust the memory block), you'll lose the pointer to your original array, causing a permanent memory leak.

Here's your original code for reference:

if(free_slots == 50) { 
    big_num_Arr =(bignum *) realloc (big_num_Arr,(capacity-40)*sizeof(bignum)); 
    free_slots = 10; 
    capacity -= 40; 
}

If realloc returns NULL, you overwrite big_num_Arr with NULL, and the original array's memory is now unreachable—you can't free it anymore.

Fixed Version #

Always store the realloc result in a temporary pointer first, check if it's valid, then update your original pointer:

if(free_slots == 50) {
    // Use a temp pointer to hold realloc's result
    bignum *temp_arr = realloc(big_num_Arr, (capacity - 40) * sizeof(bignum));
    if (temp_arr != NULL) {
        // Only update the original pointer if realloc succeeded
        big_num_Arr = temp_arr;
        free_slots = 10;
        capacity -= 40;
    } else {
        // Handle allocation failure (e.g., log an error, keep using the original array)
        fprintf(stderr, "Failed to shrink bignum array: out of memory\n");
    }
}

Extra: Don't Forget Struct-internal Dynamic Memory #

Your bignum struct has a char *digit pointer, which I assume is dynamically allocated (since it's part of a big number implementation). If that's the case, shrinking the array will discard the last 40 bignum elements—but realloc won't automatically free the digit pointers inside those discarded elements.

This means those digit buffers will be left hanging in the heap, causing a subtle memory leak. To fix this, you need to manually free those internal pointers before shrinking the array:

if(free_slots == 50) {
    // First, free the digit pointers of the elements we're about to discard
    for (int i = capacity - 40; i < capacity; i++) {
        free(big_num_Arr[i].digit);
        // Optional: Set digit to NULL to avoid dangling pointers
        big_num_Arr[i].digit = NULL;
    }

    // Now safely shrink the array
    bignum *temp_arr = realloc(big_num_Arr, (capacity - 40) * sizeof(bignum));
    if (temp_arr != NULL) {
        big_num_Arr = temp_arr;
        free_slots = 10;
        capacity -= 40;
    } else {
        fprintf(stderr, "Failed to shrink bignum array: out of memory\n");
    }
}

Final Recap #

• Shrinkage via realloc itself doesn't leak memory—the excess array memory is returned to the system.
• Always use a temporary pointer to check realloc success, or you risk losing your original array.
• If your struct contains internal dynamic memory, free those resources before discarding struct elements with realloc.

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