零.前言

1.基本概念

1.什么是動態記憶體

2.開辟動態記憶體的作用

1.在堆疊區開辟的空間

2.在堆區開辟空間

2.動態記憶體開辟的函式

1.void *malloc( size_t size )

1.含義

2.引數

3.回傳值

4.用法

5.注意事項

2.void free( void *memblock )

1.含義

2.引數

3.回傳值

4.用法

5.注意事項

3.void *calloc( size_t num, size_t size )

1.含義

2.引數

3.回傳值

4.用法

4.void *realloc( void *memblock, size_t size )

1.含義

2.引數

3.回傳值

4.用法

3.動態記憶體開辟中常見的錯誤

1.對空指標的解參考操作

2.動態記憶體開辟的越界訪問

3.對非動態記憶體開辟的空間使用了free

4.使用free釋放開辟空間的一部分

5.對一塊記憶體進行多次釋放

6.動態記憶體開辟忘記釋放

4.經典筆試題

1.筆試題1

2.筆試題2

3.筆試題3

4.筆試題4

5.柔性陣列

1.含義

2.特點

3.舉例

4.柔性陣列的優勢

1.方便記憶體釋放

2.有利于提高訪問速度

6.總結

零.前言

時間與空間，構成了我們處的這個世界，在神奇寶貝中，分別由帝牙盧卡和帕路奇犽所掌管，但在我們碼農的世界里，無數大佬朝朝思，夜夜想如何節省空間的同時又能夠節省時間，于是發明了好多復雜度的計算方法，如果說在堆疊中的存盤是為了時間考慮，那動態記憶體的開辟則是為了空間的優勢，

1.基本概念

1.什么是動態記憶體

大家看這樣一幅圖片，我們通常定義的變數是在堆疊區為他分配空間，而如果使用malloc，calloc，realloc這樣的函式就是在堆區為他開辟空間，

1.堆疊區：在執行函式時，函式內區域變數的存盤單元都可以在堆疊上創建，函式執行結束時這些記憶體單元自動被釋放，堆疊記憶體分配運算內置于處理器的指令集中，效率更高，但是分配的記憶體容量有限，堆疊區主要存放運行函式而分配的區域變數，函式引數，回傳資料，回傳地址等，

2.堆區：一般由程式員分配釋放，若程式員不釋放，程式結束時可能由OS回收，分配方式類似于鏈表，

3.資料段（靜態區）：存放全域變數，靜態資料，程式結束后由系統釋放，

4.代碼段：存放函式體（類成員函式和全域函式）的二進制代碼，

有了這張圖我們也可以理解static關鍵字的含義了：

實際上普通的區域變數是在堆疊區分配空間的，堆疊區的特點是在上面創建的變數出了作用于就銷毀，

但是被static修飾的變數存放在資料段（靜態區），資料段的特點是在上面創建的變數，直到程式結束時才銷毀所以生命周期變長，

2.開辟動態記憶體的作用

1.在堆疊區開辟的空間

#include<stdio.h>
void print(int* n)
{
	int a = 10;
	n = &a;
}
int main()
{
	int* p = NULL;
	print(p);
	printf("%d", *p);
	return 0;
}

這段代碼就是問題代碼，雖然在函式中p通過n確實指向了a這塊空間，但是出函式之后，a這段空間就釋放了，使得p變成了一個野指標，所以不能進行解參考，

2.在堆區開辟空間

在堆區開辟的空間，空間是否釋放是由用戶決定的，并不是出某個空間就自動釋放，下面就來介紹如何在堆區開辟空間，

動態記憶體開辟相對于在堆疊區開辟空間還有一個好處，當在堆疊區開辟空間時，需要一下子全都開辟完，比如開辟了一個1000個元素的陣列，但最終只使用了30個元素，那么其他970個空間就發生了浪費，而在堆區開辟空間，可以用到哪里開辟到哪里，因為即使退出了加入資料的元素，之前加入的元素也不會被釋放，再加入元素時只需要再次呼叫這個函式就可以了，

2.動態記憶體開辟的函式

1.void malloc( size_t size* )

1.含義

在堆區開辟空間，

2.引數

size表示開辟的空間為size個位元組，

3.回傳值

回傳一個空型別的指標，該指標指向開辟的空間的首地址，

4.用法

由于我們回傳的是一個空型別的指標，所以在我們想要使用這段空間的內容時，需要進行強制型別的轉換，比方說我們在堆中存放了10個整型，那么接收的時候就要用整型指標進行接收，

int i;
int* p=(int*)malloc(40);//在堆上開辟40個位元組，并將首地址賦值給p
for(i=0;i<10;i++)
{
*(p+i)=i;
}//將這段空間賦值

這樣就成功在堆區開辟了一個40個位元組的空間，用于存放10個整型（因為解參考時是4個位元組一次的訪問），

5.注意事項

1.如果開辟空間成功則回傳指向這塊空間的指標，

2.如果開辟失敗則回傳一個空指標（NULL)，

3.回傳值的型別是void*所以malloc函式不知道開辟這段空間的型別，具體的使用由使用者自己定義，

4.如果size的大小是0，malloc的標準是未定義的，行為取決于編譯器，

2.void free( void **memblock* )

1.含義

將動態記憶體開辟的空間還給作業系統，

2.引數

*memblock指動態記憶體開辟的空間的首地址，

3.回傳值

無回傳值，

4.用法

int i;
int* p=(int*)malloc(40);//在堆上開辟40個位元組，并將首地址賦值給p
for(i=0;i<10;i++)
{
*(p+i)=i;
}//將這段空間賦值
free(p);//將開辟的40個位元組的空間釋放掉
p=NULL;//將p置為空

動態記憶體開辟的空間只有在程式運行結束時或者free掉才能還給作業系統，如果等程式運行結束，就很有可能出現記憶體崩潰的情況，所以我們引入free函式來回收空間，

在free函式回收空間之后，p指標變成野指標，需要用NULL賦值，

5.注意事項

1.如果p指向的空間不是動態記憶體開辟的，那么free函式的行為是未定義的，

2.如果p是空指標，那么free函式什么都不做，

3.void calloc( size_t num, size_t size* )

1.含義

在堆中開辟一段空間并初始化為0，

2.引數

num表示開辟了幾個元素的空間，size表示一個元素開辟多大的空間，

3.回傳值

回傳一個空型別的指標，指向開辟空間的首元素的地址，

4.用法

實際上只是比malloc函式多了一個初始化的功能，

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)calloc(7, 5);//開辟七個元素，每個元素大小為5個位元組
	return 0;
}

我們在記憶體中可以看到一共開辟了35個位元組的空間，且值均賦值為0，

4.void *realloc( void **memblock, size_t size* )

1.含義

調整動態開辟空間的大小，

2.引數

memblock指向的是要更改大小的動態開辟的空間的首元素，size表示的是要增加幾個位元組的，

3.回傳值

回傳的是更改之后空間的首元素的地址，

4.用法

由于不確定在原有空間的基礎上增加空間，是否會成功，所以在使用realloc函式的時候有兩種情況：

第一種：

我們知道在開辟空間的時候，開辟的空間在記憶體中是隨機分布的，當我們在原有空間基礎上增加空間時，如果原有空間后有足夠的空間可供增加的時候我們是直接進行增加的，

第二種：

當原有空間之后的空間不夠進行再增加空間的時候，會對原有空間進行一份拷貝，再增加空間，那么此時realloc回傳的就是拷貝后空間的首元素的地址，

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int i;
	int* p = (int*)malloc(40);//在堆上開辟40個位元組，并將首地址賦值給p
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}//將這段空間賦值
	realloc(p, 40);//在原有空間基礎上增加了40個位元組
	for (i = 0; i < 20; i++)
	{
		*(p + i) = i;
	}
	for (i = 0; i < 20; i++)
	{
		printf("%d\n", *(p + i));
	}
    free(p);
    p=NULL;//釋放p指向的空間并將其初始化為0
	return 0;
}

列印的結果是：

即添加成功，

3.動態記憶體開辟中常見的錯誤

1.對空指標的解參考操作

在開辟動態記憶體時，不一定每一次都能夠開辟成功（當然大部分都能開辟成功），所以我們需要判斷一下回傳的指標是否為空，即開辟記憶體之后要進行一次判斷，

int* p=(int*)malloc(30);
if(p==NULL)
{
return -1;//如果開辟失敗回傳-1
}

2.動態記憶體開辟的越界訪問

int* p=(int*)malloc(30);
if(p==NULL)
{
return -1;//如果開辟失敗回傳-1
}
int i;
for(i=0;i<20;i++)
{
*(p+i)=i;
}

這里對動態記憶體進行了越界訪問，一共開辟了30個位元組，但是卻訪問了80個位元組，

3.對非動態記憶體開辟的空間使用了free

a=10;
int* p=&a;
free(p);

free的應用范圍只能是動態記憶體開辟的，

4.使用free釋放開辟空間的一部分

int* p=(int*)malloc(40);
p++;
free(p);此時p不指向起始元素地址，釋放的是后一部分的空間

5.對一塊記憶體進行多次釋放

int* (int*)malloc(40);
free(p);//釋放p的空間，此時p是一個野指標
free(p);//對野指標進行空間釋放，是不對的

6.動態記憶體開辟忘記釋放

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

來看這一段代碼，由于1永遠是真，所以這段代碼是無法執行結束的，所以p所指向的空間永遠得不到釋放，你可能會說實際作業中沒有執行不完的代碼，但如果工程量巨大，如果不釋放空間的話，在程式結束之前，堆區可能很快就滿了，后序的作業就無法進行了，

4.經典筆試題

1.筆試題1

void GetMemory(char *p)
{
p = (char *)malloc(100);
}
void Test(void)
{
char *str = NULL;
GetMemory(str);
strcpy(str, "hello world");
printf(str);
}

我們運行程式發現程式掛掉了：

1.str傳給p的時候是值傳遞，p是str的臨時拷貝，malloc開辟的空間起始地址放在p中不會影響str，str仍為NULL

2.str是NULL，strcpy想把hello world拷貝到str指向的空間時，程式就崩潰了，因為NULL指向的空間不能訪問，

3.記憶體泄漏，沒有free

2.筆試題2

#include<stdio.h>
#include<stdlib.h>
char* GetMemory(void)
{
	char p[] = "hello world";
	return p;
}
void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	printf(str);
}
int main()
{	
		Test();
		return 0;
}

顯然這段代碼也掛掉了，這是由于在GetMemory開辟的空間在出函式時就銷毀了，所以str接收的仍然是一個野指標，

3.筆試題3

#include<stdio.h>
#include<stdlib.h>
void GetMemory(char** p, int num)
{
	*p = (char*)malloc(num);
}
void Test(void)
{
	char* str = NULL;
	GetMemory(&str, 100);
	strcpy(str, "hello");
	printf(str);
}
int main()
{	
		void Test();
		return 0;
}

這段代碼列印的結果是：

雖然列印出來了結果是hello，這里傳遞的是str的地址，用p來接收str的地址，對str地址解參考得到str本身，使str指向100個位元組大小的空間，然后銷毀p的空間，銷毀的意思是不在程式中默認不能訪問str的地址了，不過沒關系，因為str已經指向了我們想讓他指向的內容，

4.筆試題4

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void Test(void)
{
	char* str = (char*)malloc(100);
	strcpy(str, "hello");
	free(str);
	if (str != NULL)
	{
		strcpy(str, "world");
		printf(str);
	}
}
int main()
{	
		Test();
		return 0;
}

這段代碼列印的結果是：

雖然列印出來了，但是str已經被free掉了，所以str是一個野指標，不能進行拷貝，

5.柔性陣列

1.含義

在C99標準中，結構體的最后一個元素允許是未知大小的陣列，

2.特點

1.結構中的柔性陣列成員前面必須至少有一個其他成員，

2.sizeof回傳這種結構大小中不包含柔性陣列的記憶體，

3.包含柔性陣列成員結構用malloc()函式進行動態記憶體分配，并且分配的記憶體應該大于結構的大小，以適應柔性陣列的預期大小，

3.舉例

#include<stdio.h>
struct A {
	int i;
	int a[];
};
int main()
{
	printf("%d", sizeof(struct A));
}

我們可以看出列印型別大小時并沒有算柔性陣列a的大小，

#include<stdio.h>
struct A {
	int i;
	int a[];
};
int main()
{
	struct A* p = (struct A*)malloc(sizeof(struct A) + 5 * sizeof(int));
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		p->a[i] = i;
	}
	for (i = 0; i < 5; i++)
	{
		printf("%d ", p->a[i]);
	}
	return 0;
}

在為柔性陣列開辟空間的時候，要在為結構體開辟空間之后再加上想要開辟的位元組數，

4.柔性陣列的優勢

1.方便記憶體釋放

如果我們的代碼是在一個給別人使用的函式中，你在里面做了一個二次記憶體分配，并把整個結構體回傳給用戶，用戶呼叫free可以釋放結構體，但是用戶并不知道這個結構體內的成員也需要free，所以你不能指望用戶來發現這個事情，所以，如果我們把結構體的記憶體以及其成員要的記憶體一次性分配就好了，并回傳給用戶一個結構體指標，用戶用一次free就可以把所有的記憶體給釋放掉，

2.有利于提高訪問速度

連續的記憶體有益于提高訪問速度，也有益于減少記憶體碎片，

6.總結

在第一次做資料結構實驗課的時候，鏈表部分就需要用到動態記憶體的開辟，曾經蒙了很長一段時間，動態記憶體開辟使我們對記憶體的把握更加靈活，就是訪問速度慢了一些，但是總會有代價的不是嗎，堆疊區和堆區，一個是用空間來換取時間，一個是用時間來換取空間，我們可以根據復雜度去計算，也可以把這兩種方式當薛定諤的貓的問題來處理，

轉載請註明出處，本文鏈接：https://www.uj5u.com/ruanti/305734.html

標籤：其他

上一篇：R語言回歸模型殘差可視化實戰：殘差擬合曲線圖（residual vs. fitted plot）、QQ圖、殘差密度圖

下一篇：視覺slam學習筆記以及課后習題《第二講三維物體剛體運動》

在堆區開辟記憶體（動態記憶體的開辟）

零.前言

1.基本概念

1.什么是動態記憶體

2.開辟動態記憶體的作用

1.在堆疊區開辟的空間

2.在堆區開辟空間

2.動態記憶體開辟的函式

1.void *malloc( size_t size )

1.含義

2.引數

3.回傳值

4.用法

5.注意事項

2.void free( void *memblock )

1.含義

2.引數

3.回傳值

4.用法

5.注意事項

3.void *calloc( size_t num, size_t size )

1.含義

2.引數

3.回傳值

4.用法

4.void *realloc( void *memblock, size_t size )

1.含義

2.引數

3.回傳值

4.用法

3.動態記憶體開辟中常見的錯誤

1.對空指標的解參考操作

2.動態記憶體開辟的越界訪問

3.對非動態記憶體開辟的空間使用了free

4.使用free釋放開辟空間的一部分

5.對一塊記憶體進行多次釋放

6.動態記憶體開辟忘記釋放

4.經典筆試題

1.筆試題1

2.筆試題2

3.筆試題3

4.筆試題4

5.柔性陣列

1.含義

2.特點

3.舉例

4.柔性陣列的優勢

1.方便記憶體釋放

2.有利于提高訪問速度

6.總結

1.void malloc( size_t size* )

2.void free( void **memblock* )

3.void calloc( size_t num, size_t size* )

4.void *realloc( void **memblock, size_t size* )