為什么存在動態(tài)內(nèi)存管理

我們已經(jīng)掌握的內(nèi)存開辟方式有：

int val = 20;//在?？臻g上開辟四個(gè)字節(jié)

char arr[10] = { 0 };//在?？臻g上開辟10個(gè)字節(jié)的連續(xù)空間

但是上述的開辟空間的方式有兩個(gè)特點(diǎn)：

1. 空間開辟大小是固定的。

2. 數(shù)組在申明的時(shí)候，必須指定數(shù)組的長度，它所需要的內(nèi)存在編譯時(shí)分配。 但是對于空間的需求，不僅僅是上述的情況。有時(shí)候我們需要的空間大小在程序運(yùn)行的時(shí)候才能知道， 那數(shù)組的編譯時(shí)開辟空間的方式就不能滿足了。 這時(shí)候就只能試試動態(tài)存開辟了。

動態(tài)內(nèi)存函數(shù)的介紹

malloc

C語言提供了一個(gè)動態(tài)內(nèi)存開辟的函數(shù)：

void* malloc(size_t size);

這個(gè)函數(shù)向內(nèi)存申請一塊連續(xù)可用的空間，并返回指向這塊空間的指針。

如果開辟成功，則返回一個(gè)指向開辟好空間的指針。 如果開辟失敗，則返回一個(gè)NULL指針，因此malloc的返回值一定要做檢查。 返回值的類型是 void* ，所以malloc函數(shù)并不知道開辟空間的類型，具體在使用的時(shí)候使用者自己 來決定。 如果參數(shù) size 為0，malloc的行為是標(biāo)準(zhǔn)是未定義的，取決于編譯器。

free

講完了malloc這個(gè)動態(tài)內(nèi)存函數(shù)我們就得來講講另一個(gè)動態(tài)內(nèi)存函數(shù)free，C語言提供的另外一個(gè)函數(shù)free，專門是用來做動態(tài)內(nèi)存的釋放和回收的，函數(shù)原型如下：

void free (void* ptr);

free函數(shù)用來釋放動態(tài)開辟的內(nèi)存。 如果參數(shù) ptr 指向的空間不是動態(tài)開辟的，那free函數(shù)的行為是未定義的。 如果參數(shù) ptr 是NULL指針，則函數(shù)什么事都不做。 malloc和free都聲明在 stdlib.h 頭文件中。

舉個(gè)例子來看看這兩個(gè)函數(shù)怎么用：

#include <stdio.h>
int main()
{
	int num = 0;
	scanf("%d", &num);
	int arr[num] = { 0 };
	int* ptr = NULL;
	ptr = (int*)malloc(num * sizeof(int));
	if (NULL != ptr)
	{
		int i = 0;
		for (i = 0; i < num; i++)
		{
			*(ptr + i) = 0；
		}
	}
	free(ptr);
	ptr = NULL;
	return 0;
}

calloc

除了malloc這個(gè)函數(shù)，C語言還提供了一個(gè)函數(shù)叫 calloc ， calloc 函數(shù)也用來動態(tài)內(nèi)存分配。原型如下：

void* calloc (size_t num, size_t size);

該函數(shù)的功能是為 num 個(gè)大小為 size 的元素開辟一塊空間，并且把空間的每個(gè)字節(jié)初始化為0。

與函數(shù) malloc 的區(qū)別只在于 calloc 會在返回地址之前把申請的空間的每個(gè)字節(jié)初始化為全0。

舉個(gè)例子：

#include <stdio.h>
#include <stdlib.h>
int main()
{
	int* p = (int*)calloc(10, sizeof(int));
	if (NULL != p)
	{
		int i = 0;
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));
		}
	}
	free(p);
	p = NULL;
	return 0;
}

總結(jié)：所以如何我們對申請的內(nèi)存空間的內(nèi)容要求初始化，那么可以很方便的使用calloc函數(shù)來完成任務(wù)。

realloc

realloc函數(shù)的出現(xiàn)讓動態(tài)內(nèi)存管理更加靈活。 有時(shí)會我們發(fā)現(xiàn)過去申請的空間太小了，有時(shí)候我們又會覺得申請的空間過大了，那為了合理的時(shí) 候內(nèi)存，我們一定會對內(nèi)存的大小做靈活的調(diào)整。那 realloc 函數(shù)就可以做到對動態(tài)開辟內(nèi)存大小 的調(diào)整。 函數(shù)原型如下：

void* realloc (void* ptr, size_t size);

ptr 是要調(diào)整的內(nèi)存地址

size 調(diào)整之后新大小

返回值為調(diào)整之后的內(nèi)存起始位置。

這個(gè)函數(shù)調(diào)整原內(nèi)存空間大小的基礎(chǔ)上，還會將原來內(nèi)存中的數(shù)據(jù)移動到 新 的空間。 realloc在調(diào)整內(nèi)存空間的是存在兩種情況：

情況1：原有空間之后有足夠大的空間

情況2：原有空間之后沒有足夠大的空間

情況1

當(dāng)是情況1 的時(shí)候，要擴(kuò)展內(nèi)存就直接原有內(nèi)存之后直接追加空間，原來空間的數(shù)據(jù)不發(fā)生變化。 情況2

當(dāng)是情況2 的時(shí)候，原有空間之后沒有足夠多的空間時(shí)，擴(kuò)展的方法是：在堆空間上另找一個(gè)合適大小 的連續(xù)空間來使用。這樣函數(shù)返回的是一個(gè)新的內(nèi)存地址。 由于上述的兩種情況，realloc函數(shù)的使用就要注意一些。

舉個(gè)例子：

int main()
{
    int* ptr = (int*)malloc(100);
    if (ptr != NULL)
    {
        //業(yè)務(wù)處理
    }
    else
    {
        perror("malloc)//打印錯(cuò)誤信息;
    }
    //擴(kuò)展容量
    //代碼1
    ptr = (int*)realloc(ptr, 1000);//這樣可以嗎？(如果申請失敗會如何？)
    //代碼2
    int* p = NULL;
    p = realloc(ptr, 1000);
    if (p != NULL)
    {
        ptr = p;
    }
    //業(yè)務(wù)處理
    free(ptr);
    return 0;
}

常見的動態(tài)內(nèi)存錯(cuò)誤

對NULL指針的解引用操作

void test()
{
 int *p = (int *)malloc(INT_MAX/4);
 *p = 20;//如果p的值是NULL，就會有問題，所以在這之前我們需要對返回值進(jìn)行判斷
 free(p);
 p=NULL;
}

正確寫法：

void test()
{
 int *p = (int *)malloc(INT_MAX/4);
if(p!=NULL)
{
  *p = 20;
}
 free(p);
 p=NULL;
}

對動態(tài)開辟空間的越界訪問

void test()
{
 int i = 0;
 int *p = (int *)malloc(10*sizeof(int));
 if(NULL == p)
 {
 perror("malloc)//打印錯(cuò)誤信息;
 }
 for(i=0; i<=10; i++)
 {
 *(p+i) = i;//當(dāng)i是10的時(shí)候越界訪問
 }
 free(p);
}

正確寫法：

void test()
{
 int i = 0;
 int *p = (int *)malloc(10*sizeof(int));
 if(NULL == p)
 {
 perror("malloc)//打印錯(cuò)誤信息;
 }
 for(i=0; i<10; i++)
 {
 *(p+i) = i;//當(dāng)i是10的時(shí)候越界訪問
 }
 free(p);
}

對非動態(tài)開辟內(nèi)存使用free訪問

void test()
{
 int a = 10;
 int *p = &a;
 free(p);//p指向的是非動態(tài)內(nèi)存，free只能用于動態(tài)內(nèi)存的釋放
}

使用free 釋放一塊動態(tài)開辟內(nèi)存的一部分

void test()
{
 int *p = (int *)malloc(100);
 p++;
 free(p);//p不再指向動態(tài)內(nèi)存的起始位置
}

free函數(shù)要從動態(tài)內(nèi)存的起始地址開始釋放

對一塊動態(tài)內(nèi)存多次釋放

void test()
{
 int *p = (int *)malloc(100);
 free(p);
 p=NULL;
 free(p);//重復(fù)釋放
 p=NULL;
}

對動態(tài)內(nèi)存開辟忘記釋放

void test()
{
 int *p = (int *)malloc(100);
 if(NULL != p)
 {
 *p = 20;
 }
}
int main()
{
 test();
 while(1);
}

動態(tài)開辟內(nèi)存如果忘記釋放會造成內(nèi)存泄漏。所以開辟的空間在用完之后一定記得釋放，并且正確釋放。

接下來再來看看一個(gè)題目，也是一個(gè)常見的錯(cuò)誤：

char *GetMemory(void)
{
 char p[] = "hello world";
 return p;
}
void Test(void)
{
 char *str = NULL;
 str = GetMemory();
 printf(str);
}

柔性數(shù)組

或許你從來沒有聽說過柔性數(shù)組（flexible array）這個(gè)概念，但是它確實(shí)是存在的。 C99 中，結(jié)構(gòu)中的最后一個(gè)元素允許是未知大小的數(shù)組，這就叫做『柔性數(shù)組』成員。

例如：

typedef struct st_type
{
 int i;
 int a[0];//柔性數(shù)組成員
}type_a;

有些編譯器會報(bào)錯(cuò)無法編譯可以改成：

typedef struct st_type
{
 int i;
 int a[];//柔性數(shù)組成員
}type_a;

柔性數(shù)組的特點(diǎn)：

結(jié)構(gòu)中的柔性數(shù)組成員前面必須至少一個(gè)其他成員。

sizeof 返回的這種結(jié)構(gòu)大小不包括柔性數(shù)組的內(nèi)存。

包含柔性數(shù)組成員的結(jié)構(gòu)用malloc ()函數(shù)進(jìn)行內(nèi)存的動態(tài)分配，并且分配的內(nèi)存應(yīng)該大于結(jié)構(gòu)的大 小，以適應(yīng)柔性數(shù)組的預(yù)期大小。

舉個(gè)例子：

typedef struct st_type
{
 int i;
 int a[0];//柔性數(shù)組成員
}type_a;
int main()
{
  printf("%d\n", sizeof(type_a));//輸出的是4
  return 0;
}

柔性數(shù)組的使用：

typedef struct st_type
{
 int i;
 int a[0];//柔性數(shù)組成員
}type_a;
int main()
{
  int i = 0;
  type_a *p = (type_a*)malloc(sizeof(type_a)+100*sizeof(int));
  //業(yè)務(wù)處理
  p->i = 100;
  for(i=0; i<100; i++)
{
  p->a[i] = i;
}
  free(p);
  p=NULL;
  return 0;
}

這樣柔性數(shù)組成員a，相當(dāng)于獲得了100個(gè)整型元素的連續(xù)空間。

柔性數(shù)組的優(yōu)勢：

//非柔性數(shù)組開辟空間
typedef struct st_type
{
 int i;
 int *p_a;
}type_a;
int main()
{
type_a *p = (type_a *)malloc(sizeof(type_a));
p->i = 100;
p->p_a = (int *)malloc(p->i*sizeof(int));
//業(yè)務(wù)處理
for(i=0; i<100; i++)
{
 p->p_a[i] = i;
}
//釋放空間
free(p->p_a);
p->p_a = NULL;
free(p);
p = NULL;
return 0;
}
 

//柔性數(shù)組開辟空間
typedef struct st_type
{
 int i;
 int a[0];//柔性數(shù)組成員
}type_a;
int main()
{
  int i = 0;
  type_a *p = (type_a*)malloc(sizeof(type_a)+100*sizeof(int));
  //業(yè)務(wù)處理
  p->i = 100;
  for(i=0; i<100; i++)
{
  p->a[i] = i;
}
  free(p);
  p=NULL;
  return 0;
}

上述 代碼1 和 代碼2 可以完成同樣的功能，但是 方法2 的實(shí)現(xiàn)有兩個(gè)好處：

第一個(gè)好處是：方便內(nèi)存釋放 如果我們的代碼是在一個(gè)給別人用的函數(shù)中，你在里面做了二次內(nèi)存分配，并把整個(gè)結(jié)構(gòu)體返回給 用戶。用戶調(diào)用free可以釋放結(jié)構(gòu)體，但是用戶并不知道這個(gè)結(jié)構(gòu)體內(nèi)的成員也需要free，所以你 不能指望用戶來發(fā)現(xiàn)這個(gè)事。所以，如果我們把結(jié)構(gòu)體的內(nèi)存以及其成員要的內(nèi)存一次性分配好 了，并返回給用戶一個(gè)結(jié)構(gòu)體指針，用戶做一次free就可以把所有的內(nèi)存也給釋放掉。

第二個(gè)好處是：這樣有利于訪問速度. 連續(xù)的內(nèi)存有益于提高訪問速度，也有益于減少內(nèi)存碎片

小結(jié)

以上就是我對動態(tài)內(nèi)存管理的理解，如有錯(cuò)誤，請大家指正，我們一起學(xué)習(xí)。

到此這篇關(guān)于C語言深入細(xì)致講解動態(tài)內(nèi)存管理的文章就介紹到這了,更多相關(guān)C語言動態(tài)內(nèi)存管理內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論