为何C语言未提供获取malloc分配内存大小的函数？

Great question—this is something that trips up a lot of people when they first dig into how dynamic memory allocation works under the hood. Let’s break down why the C standard doesn’t include a function to retrieve the size of a malloc’d block, even though most implementations do store that information.

1. C’s design philosophy: Minimalism and portability #

C was built to be a lightweight, portable language that gives programmers direct control over hardware and memory. The standard library only includes features that can be consistently implemented across all platforms—from tiny embedded systems to high-end servers.

Malloc implementations vary wildly:

• Some store the block size in a header immediately before the returned pointer (like glibc’s ptmalloc).
• Others might track sizes in a separate metadata structure (e.g., a linked list of free/used blocks).
• On resource-constrained systems, malloc might even skip storing size info entirely (using a simple pool of fixed-size blocks, for example).

Adding a standard malloc_get_size() function would force all implementations to conform to a specific way of storing metadata, which goes against C’s ethos of letting implementers optimize for their target environment.

2. Safety and programmer responsibility #

C trusts programmers to manage their own memory—and that includes keeping track of how much memory they allocated. A standard size-retrieval function could lead to bad habits:

• Programmers might rely on it to avoid tracking sizes themselves, which increases the risk of bugs if the pointer is corrupted (e.g., by an out-of-bounds write or a wild pointer). Calling such a function with an invalid pointer could return garbage data or crash the program.
• It might encourage lazy programming, where developers skip validating memory boundaries because they think they can “just get the size later.” This undermines C’s focus on explicit, controlled memory management.

3. Platform-specific alternatives exist (but aren’t standard) #

While the C standard doesn’t include this feature, most major platforms do provide their own non-standard functions:

• On Linux and macOS: malloc_usable_size() (returns the actual usable size of the block, which might be larger than what you requested due to alignment).
• On Windows: _msize() (returns the size you originally requested).

These work for their respective systems, but they’re not portable—using them locks your code to a specific platform, which the C standard aims to avoid.

A workaround: Roll your own tracked allocation #

If you really need to track allocated sizes in a portable way, you can wrap malloc/free with your own functions that store the size alongside the memory block. For example:

#include <stdlib.h>
#include <stddef.h>

// A struct to hold metadata + the actual data
typedef struct {
    size_t size;
    char data[]; // Flexible array member (C99+)
} TrackedBlock;

void* my_malloc(size_t size) {
    // Allocate space for the metadata + the requested data
    TrackedBlock* block = malloc(sizeof(TrackedBlock) + size);
    if (!block) return NULL;
    
    block->size = size;
    return block->data; // Return a pointer to the data, not the metadata
}

size_t my_malloc_size(void* ptr) {
    if (!ptr) return 0;
    
    // Backtrack from the data pointer to the metadata struct
    TrackedBlock* block = (TrackedBlock*)((char*)ptr - offsetof(TrackedBlock, data));
    return block->size;
}

void my_free(void* ptr) {
    if (!ptr) return;
    
    TrackedBlock* block = (TrackedBlock*)((char*)ptr - offsetof(TrackedBlock, data));
    free(block);
}

This gives you portable size tracking without relying on platform-specific functions.

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