#include <stdio.h>
#include <string.h>
#include <stdlib.h>
char *say_hi();

int main(int argc, char *argv[])
{
   char *str = say_hi();
   printf("str = %s\n", str);
   free(str);
   return 0;
}

char *say_hi()
{
   char *ptr = (char *)malloc(100);
   char *str = "how are you?";
   strcpy(ptr, str);
  
   return ptr;
}

執(zhí)行結果如下：

[root@localhost compiler-basic]# gcc -o t t.c -g -m32
[root@localhost compiler-basic]# ./t
str = how are you?

把修改成：

char *say_hi()
{
   char *ptr = (char *)malloc(100);
   char *str = "how are you?";
   strcpy(ptr, str);
  
   return str;
}

執(zhí)行結果如下：

[root@localhost compiler-basic]# gcc -o t t.c -g -m32
[root@localhost compiler-basic]# ./t
str = how are you?
Segmentation fault (core dumped)

在第二版say_hi中，返回值是str，我們看到，打印出的數(shù)據是how are you?。然而，這只是偶爾正確。C語言的函數(shù)并不能總是正確返回非數(shù)字類型的局部變量的值。在程序變得復雜后，保不準某個時候這樣的函數(shù)就不能返回預期數(shù)據。

Segmentation fault (core dumped)，這又是怎么回事呢？str不是malloc申請到的內存空間，用free釋放它導致錯誤。

2.內存泄露

用malloc申請了內存空間卻不用free釋放，會造成內存泄露。

在前面的第二版say_hi中，ptr指向的內存空間就被泄露了。在程序員看來，執(zhí)行完say_hi后，ptr指向的內存就沒有價值了；由于沒有正確地釋放它，操作系統(tǒng)認為它仍然在使用中，當其他進程申請內存時，不會把這片內存回收重新分配。

像這樣的內存泄露越來越多，會一直多到耗盡所有的內存。但實際上，那些被泄露的內存是完全應該被回收再使用的。

內存泄露后，會成為操作系統(tǒng)和程序員都無法掌控的內存。

我們在手工申請內存、使用完畢之后，一定要釋放內存。malloc和free猶如一對連體嬰兒，總是一起使用。

3.內存池

前面的例子，在say_hi使用malloc，在main使用free。連體嬰兒卻只能出現(xiàn)在兩個函數(shù)中，這很危險。一不留神，就會忘記釋放內存。

每次申請內存都使用malloc，需要陷入內核，性能開銷很大。

有朋友會說，我只是個小菜鳥，暫時還不需要考慮性能開銷，只要我寫的程序能跑就行。

哈哈，你并不是第一個這么想的人，我也是這樣想的，所以我不厭其煩地、勤快地多次使用malloc。終于，在昨天，我遇到了非常煩人的段錯誤。

段錯誤發(fā)生在malloc中，導致錯誤的函數(shù)調用鏈不同，在測試數(shù)據中隨便加幾個字符后錯誤又消失。斷點調試不管用，在前幾十次執(zhí)行malloc沒有段錯誤，在后面幾十次中的某一次執(zhí)行malloc時才出現(xiàn)段錯誤。段錯誤出現(xiàn)在內核中。內核是不會有問題的，即使問題指向內核，那一定是向內核提供了錯誤的輸入數(shù)據。

在束手無策快要絕望之前，我把原始的malloc換成了向內存池申請內存。先前發(fā)生的奇怪錯誤，再也沒有出現(xiàn)了。

4.理論

內存池，是使用malloc申請的一段內存；進程需要內存空間時，從這段內存中拿一塊去用；當這段內存被用完后，再使用malloc申請一段新內存；像這樣重復這個過程。

很容易發(fā)現(xiàn)，內存池減少了使用malloc的次數(shù)；在進程結束前，程序員能方便地一次性釋放這些內存。

5.代碼數(shù)據結構

struct mblock{
   char *begin;
   char *avail;
   char *end;
};

typedef struct heap{
  struct mblock *last;
   struct mblock head;
} *Heap;

#define HEAP(hp) struct heap hp = { &hp.head }
Heap CurrentHeap;
struct heap ProgrameHeap;
int HeapAlloc(Heap hp, int size);
void *do_malloc(int size);

6.代碼

char *HeapAlloc(Heap hp, int size){
   struct mblock *blk = NULL;
   blk = hp->last;
  
   while(size > blk->end - blk->avail){
       int m = 4096 + sizeof(struct mblock) + size;
       blk->next = malloc(m);
       blk = blk->next;
       if(blk == NULL){
           printf("內存耗盡\n");
           exit(-1);
        }
       blk->begin = blk->avail = (char *)(blk + 1);
       blk->end = (char *)blk + m;
       hp->last = blk;
    }
  
   blk->avail += size;
  
   return blk->avail - size;
}

void *do_malloc(int size){
  CurrentHeap = HEAP(ProgrameHeap);
   void *p = HeapAlloc(CurrentHeap, size);
   memset(p, 0, size);
  
   return 0;
}

要申請內存的時候，原來是使用malloc，現(xiàn)在，我們有了上面的這套內存管理機制后，就使用do_malloc來申請內存。

**解說
HEAP**
這個宏把heap的第一個成員last的值設置成第二個成員head的內存地址。

要熟悉這種{ &hp.head }初始化結構體的語法。

7.blk->begin

blk->begin = blk->avail = (char *)(blk + 1);

先看blk + 1。它表示，在blk的基礎上，往后移動sizeof(struct mblock)個字節(jié)。指針的加減就是這么計算的。

blk指向一段m個字節(jié)的內存空間，這段內存空間的前sizeof(struct mblock)個字節(jié)存儲一個mblock結構。怎么理解這個結構？它是這段內存空間的元數(shù)據。了解文件系統(tǒng)的實現(xiàn)機制的朋友會很容易理解這一點。

從元數(shù)據中，獲取begin、avail、end。

如果把blk->begin做如下修改。

blk->begin = blk->avail = (char *)(blk);

怎么樣？我們來推演一番。

第一次執(zhí)行HeapAlloc，申請了一段內存，這段內存的前面是元數(shù)據；返回給進程的是這段內存的開始地址，也就是元數(shù)據的開始地址。
執(zhí)行memset(p, 0, size);，元數(shù)據被擦除。
再次執(zhí)行HeapAlloc，元數(shù)據end、avail不再是前一次執(zhí)行HeapAlloc后設置的值，無法知曉內存池是否還有內存可以分配；已經亂套了。

blk->end最后一個問題，理解下面的代碼。