void *malloc(int size); 

void *malloc (long numbytes)：该函数负责分配 numbytes 大小的内存，并返回指向第一个字节的指针。
void free(void *firstbyte)：如果给定一个由先前的 malloc 返回的指针，那么该函数会将分配的空间归还给进程的“空闲空间”。

 //清单 1. 我们的简单分配程序的全局变量int has_initialized = 0;
void *managed_memory_start;
void *last_valid_address;

清单 2. 分配程序初始化函数
/* Include the sbrk function */#include
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;
}

//清单 3. 内存控制块结构定义
struct mem_control_block {int is_available;int size;
};

//清单4. 解除分配函数
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;
}

 1 //清单 6. 主分配程序
 2 void *malloc(long numbytes) {
 3     /* Holds where we are looking in memory */
 4     void *current_location;
 5     /* This is the same as current_location, but cast to a
 6     * memory_control_block
 7     */
 8     struct mem_control_block *current_location_mcb;
 9     /* This is the memory location we will return.  It will
10     * be set to 0 until we find something suitable
11     */
12     void *memory_location;
13     /* Initialize if we haven''t already done so */
14     if(! has_initialized) {
15         malloc_init();
16     }
17     /* The memory we search for has to include the memory
18     * control block, but the users of malloc don''t need
19     * to know this, so we''ll just add it in for them.
20     */
21     numbytes = numbytes + sizeof(struct mem_control_block);
22     /* Set memory_location to 0 until we find a suitable
23     * location
24     */
25     memory_location = 0;
26     /* Begin searching at the start of managed memory */
27     current_location = managed_memory_start;
28     /* Keep going until we have searched all allocated space */
29     while(current_location != last_valid_address)
30     {
31     /* current_location and current_location_mcb point
32     * to the same address.  However, current_location_mcb
33     * is of the correct type, so we can use it as a struct.
34     * current_location is a void pointer so we can use it
35     * to calculate addresses.
36         */
37         current_location_mcb =
38             (struct mem_control_block *)current_location;
39         if(current_location_mcb->is_available)
40         {
41             if(current_location_mcb->size >= numbytes)
42             {
43             /* Woohoo!  We''ve found an open,
44             * appropriately-size location.
45                 */
46                 /* It is no longer available */
47                 current_location_mcb->is_available = 0;
48                 /* We own it */
49                 memory_location = current_location;
50                 /* Leave the loop */
51                 break;
52             }
53         }
54         /* If we made it here, it''s because the Current memory
55         * block not suitable; move to the next one
56         */
57         current_location = current_location +
58             current_location_mcb->size;
59     }
60     /* If we still don''t have a valid location, we''ll
61     * have to ask the operating system for more memory
62     */
63     if(! memory_location)
64     {
65         /* Move the program break numbytes further */
66         sbrk(numbytes);
67         /* The new memory will be where the last valid
68         * address left off
69         */
70         memory_location = last_valid_address;
71         /* We''ll move the last valid address forward
72         * numbytes
73         */
74         last_valid_address = last_valid_address + numbytes;
75         /* We need to initialize the mem_control_block */
76         current_location_mcb = memory_location;
77         current_location_mcb->is_available = 0;
78         current_location_mcb->size = numbytes;
79     }
80     /* Now, no matter what (well, except for error conditions),
81     * memory_location has the address of the memory, including
82     * the mem_control_block
83     */
84     /* Move the pointer past the mem_control_block */
85     memory_location = memory_location + sizeof(struct mem_control_block);
86     /* Return the pointer */
87     return memory_location;
88  }