请用C语言编写 malloc realloc free 这三个函数？题目如下所示

Question

malloc（）realloc（）free（）最好不要复制 C库里的只是C语言。

Answer 1

//IBM的实现，仅供参考
/* Include the sbrk function */
#include <unistd.h>

int has_initialized = 0;
void *managed_memory_start;
void *last_valid_address;

void malloc_init()
{
/* grab the last valid address from the OS */
last_valid_address = sbrk(0);

/* we don't have any memory to manage yet, so
*just set the beginning to be last_valid_address
*/
managed_memory_start = last_valid_address;

/* Okay, we're initialized and ready to go */
has_initialized = 1;
}

struct mem_control_block {
int is_available;
int size;
};

void free(void *firstbyte) {
struct mem_control_block *mcb;

/* Backup from the given pointer to find the
* mem_control_block
*/
mcb = firstbyte - sizeof(struct mem_control_block);
/* Mark the block as being available */
mcb->is_available = 1;
/* That's It! We're done. */
return;
}

void *malloc(long numbytes) {
/* Holds where we are looking in memory */
void *current_location;

/* This is the same as current_location, but cast to a
* memory_control_block
*/
struct mem_control_block *current_location_mcb;

/* This is the memory location we will return. It will
* be set to 0 until we find something suitable
*/
void *memory_location;

/* Initialize if we haven't already done so */
if(! has_initialized) {
malloc_init();
}

/* The memory we search for has to include the memory
* control block, but the user of malloc doesn't need
* to know this, so we'll just add it in for them.
*/
numbytes = numbytes + sizeof(struct mem_control_block);

/* Set memory_location to 0 until we find a suitable
* location
*/
memory_location = 0;

/* Begin searching at the start of managed memory */
current_location = managed_memory_start;

/* Keep going until we have searched all allocated space */
while(current_location != last_valid_address)
{
/* current_location and current_location_mcb point
* to the same address. However, current_location_mcb
* is of the correct type so we can use it as a struct.
* current_location is a void pointer so we can use it
* to calculate addresses.
*/
current_location_mcb =
(struct mem_control_block *)current_location;

if(current_location_mcb->is_available)
{
if(current_location_mcb->size >= numbytes)
{
/* Woohoo! We've found an open,
* appropriately-size location.
*/

/* It is no longer available */
current_location_mcb->is_available = 0;

/* We own it */
memory_location = current_location;

/* Leave the loop */
break;
}
}

/* If we made it here, it's because the Current memory
* block not suitable, move to the next one
*/
current_location = current_location +
current_location_mcb->size;
}

/* If we still don't have a valid location, we'll
* have to ask the operating system for more memory
*/
if(! memory_location)
{
/* Move the program break numbytes further */
sbrk(numbytes);

/* The new memory will be where the last valid
* address left off
*/
memory_location = last_valid_address;

/* We'll move the last valid address forward
* numbytes
*/
last_valid_address = last_valid_address + numbytes;

/* We need to initialize the mem_control_block */
current_location_mcb = memory_location;
current_location_mcb->is_available = 0;
current_location_mcb->size = numbytes;
}

/* Now, no matter what (well, except for error conditions),
* memory_location has the address of the memory, including
* the mem_control_block
*/

/* Move the pointer past the mem_control_block */
memory_location = memory_location + sizeof(struct mem_control_block);

/* Return the pointer */
return memory_location;
}