一，堆記憶體

1,堆記憶體特點

堆記憶體可以存放任意型別的資料，但需要自己申請與釋放。

2，堆大小

堆大小，想像中的無窮大，但實際使用中，受限於實際記憶體的大小和記憶體是否有連續性。

二，堆記憶體的申請與釋放

1，malloc函式

• 函式宣告：·void *malloc(size_t Size)

• 所在檔案：stdlib.h

• 引數：size_t Size （Size表示要申請的位元組數）

• 返回值：void * （成功則返回“指向申請空間的指標”，失敗則返回NULL）

• 函式功能：申請Size個位元組的堆記憶體並返回記憶體空間首地址

2，calloc函式

• 函式宣告：void *calloc(size_t nmemb,size_t size)

• 所在檔案：stdlib.h

• 引數：size_t nmemb size_t size（申請nmemb個大小為size的記憶體單元）

• 返回值：void * （成功則返回“指向申請空間的指標”，失敗則返回NULL）

• 函式功能：申請具有若干個具有固定單元大小的堆記憶體空間，自動清零

3，realloc函式

• 函式宣告：void *realloc（void *ptr,size_t size）

• 所在檔案：stdlib.h

• 引數：void *ptr ,size_t size （ptr表示原有堆記憶體空間的指標，size表示擴容後的堆記憶體空間的大小，擴容後的指標可能會改變，若原堆記憶體空間“後”沒有足夠的連續堆記憶體空間提供擴容）

• 返回值：void * （對原堆內空間進行擴容）

• 功能：對原堆內空間進行擴容

4,free函式

• 函式宣告：void free(void *p)

• 所在檔案：stdlib.h

• 引數：void *p(指向堆內申請的合法空間)

• 返回值：void

• 功能：釋放手動申請的堆內合法記憶體空間

示例：

#include<stdio.h>
#include<stdlib.h>

int main()
{
  short *p=malloc(100);//以位元組為單位
  if(NULL == p)
  {  
    printf("Malloc Error!\n");
    return
 
 -1;
  }
  free(p)；
int
}

realloc函式只能擴容而不能縮容。
realloc函式擴容之後返回的指標和指標可能不同，可能相同。因為，若在原堆記憶體空間之後有足夠大的並且是連續的空間供擴容使用，則返回的指標與原指標相同；否則，就會另找一塊足夠大的連續空間開闢“擴容後大小”的 堆記憶體空間，將原堆記憶體空間裡的值複製到新的記憶體空間並釋放掉原堆記憶體空間。最後，返回新開闢的堆記憶體空間的首地址。

三，應用（動態陣列）

#include<stdio.h>
#include<stdlib.h>

int main()
{
  int Size,newSize;
  printf("Please input Array Size:\n");
  scanf("%d",&Size);
  int *pa=(int *)malloc(Size,sizeof(int));
  if(NULL == pa)
    return -1;
  for(int I=0;i<Size；++i)
  {
    pa[i]=i;
  }

  printf("Please input Array New Size:\n");
  scanf("%d",&newSize);
  pa=(int *)realloc(newSize,sizeof(int));
  if(NULL == pa)
    return -1;
  for(int i=Size;i<newSize;++i)
  {
    pa[i]=1000;
  }

printf("Output Array!\n");
for(int I=0;i<newSize;++i)
{
  printf("%d\n",pa[i]);
}
return 0;
}

四，錯誤案例

以下三個模型，是針對堆記憶體的使用特點而設計的：

• 自申請、自釋放

• 返回判空

• 配對使用

1，申請返回判空

釋放以後未置為NULL或繼續使用

char *p=(char *)malloc(100);
if(NULL == p)
{
  return -1;
}
strcpy(p,"hello");
free(p);
//p指向的空間被釋放，但p內儲存的地址仍然存在，並且變成非法空間
p=NULL;
//將p置為空（NULL），防止p所指向的空間被使用
//若僅僅釋放而不置空，則可能會出現下來的錯誤
if(NULL != p)
{
  strcpy(p,"hello");//會因為使用了非法記憶體而出錯
}

2，伺服器模型

未釋放原有空間，而重新申請新空間，造成原有空間記憶體洩漏

while(1)
{
  char *p=(char *)malloc(1000);//在堆上申請空間
  if(NULL == p)
  {
    printf("Malloc Error!\n");
    return -1;
  }
  printf("XXXXXX\n");
  printf("oooooo\n");
  p=(char *)malloc(1000);
  //之前在堆上申請的空間尚未釋放而又申請了一段新的空間，造成記憶體洩漏
  free(p);
}

3，誰申請誰釋放模型（並非絕對）

如果沒有協同的原則，則可能會造成重複釋放

  void func(char *p)
  {
    strcpy(p,"America");
    printf("%s\n",p);
    free(p);//此處違反了誰申請誰釋放的原則
  }
  int main()
  {
    char *p=(char *)malloc(100);
    if(NULL == p)
    {
      printf("Malloc Error!\n");
      return -1;
    }
    func(p);
    free(p);//main中申請的堆空間，在main函式中釋放
    return 0;
  }