一、動態內存分配

1、為什么存在動態內存分配

1. 空間開辟大小是固定的
2. 數組在聲明的時候，必須指定數組的長度，它所需要的內存在編譯時分配

1. 堆區
2. malloc calloc realloc free

二、malloc

在堆區上申請size_t大小的空間 返回這塊空間的起始位置

void* malloc(size_t t);

1、malloc、free

這個函數向內存申請一塊連續可用的空間，并返回指向這塊空間的指針。

1. 如果開辟成功，則返回一個指向開辟好空間的指針。
2. 如果開辟失敗，則返回一個NULL指針，因此malloc的返回值一定要做檢查。
3. 返回值的類型是 void* ，所以malloc函數并不知道開辟空間的類型，具體在使用的時候使用者自己來決定。
4. 如果參數 size 為0，malloc的行為是標準是未定義的，取決于編譯器。

free函數用來釋放動態開辟的內存。

1. 如果參數 ptr 指向的空間不是動態開辟的，那free函數的行為是未定義的。
2. 如果參數 ptr 是NULL指針，則函數什么事都不做。

#include #include int main(){	// 1. 開辟空間	int* p = (int*)malloc(40); // 申請40大小空間 把起始地址強轉為int* 賦給p	if (p == NULL)	{		return -1;	}	// 開辟成功了 可以使用	int i = 0;	for (i = 0; i < 10; i++)	{		*(p + i) = i;	}	// 2. 釋放空間	free(p);	p = NULL; // 	return 0;}

2、calloc

void* calloc (size_t num, size_t size);

2.1、與malloc 的區別

malloc函數只負責在堆區申請空間，并且返回起始地址，不初始化空間
calloc函數在堆區上申請空間，并且在返回起始地址之前把申請的每個字節初始化為0

#include #include #include int main(){	int* p = (int*)calloc(10, sizeof(int));	if (p == NULL)	{		printf("%s/n", strerror(errno));		return -1;	}	// 申請成功	int i = 0;	for (i = 0; i < 10; i++)	{		printf("%d ", *(p + i));	}	// 釋放空間	free(p);	p = NULL;	return 0;}

3、realloc

讓動態內存管理更加靈活

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

ptr 是要調整的內存地址
size 調整之后新大小
返回值為調整之后的內存起始位置。
這個函數調整原內存空間大小的基礎上，還會將原來內存中的數據移動到 新 的空間

兩種情況：

1. 后面空間大小夠用，直接在后面開辟
2. 空間不夠，在堆空間上另找一個合適大小的連續空間來使用，這樣函數返回的是一個新的內存地址

#include #include #include int main(){	int* p = (int*)calloc(10, sizeof(int));	if (p == NULL)	{		printf("%s/n", strerror(errno));		return -1;	}	int i = 0;	for (i = 0; i < 10; i++)	{		*(p + i) = i;	}	// 空間不夠大，增加空間至20int	int* ptr = (int*)realloc(p, 20 * sizeof(int));	if (ptr != NULL)	{		p = ptr;	}	else	{		return -1;	}	// 增加成功，使用	for (i = 10; i < 20; i++)	{		*(p + i) = i;	}	for (i = 0; i < 20; i++)	{		printf("%d ", *(p + i));	}	free(p);	p = NULL;	return 0;}

4、常見錯誤

4.1、 對malloc返回值判斷

int* p = (int*)malloc(20);*p = 0; // 有風險

#include #include int main(){	int* p = (int*)malloc(20);	if (p == NULL)	{		return -1;	}	*p = 0;	return 0;}

4.2、對動態內存空間的越界訪問

#include #include int main(){	int* p = (int*)malloc(200);	if (p == NULL)	{		return -1;	}	int i = 0;	for (i = 0; i < 80; i++)	{		*(p + i) = 1;	}		for (i = 0; i < 80; i++)	{		printf("%d ", *(p + i));	}	free(p);	p = NULL;	return 0;}

4.3、釋放非動態內存空間

int main(){	int a = 10;	int* p = &a;	free(p); // err	p = NULL;	return 0;}

4.4、使用free釋放一塊動態開辟內存的一部分

改變了p 不再指向起始位置 此時釋放的不在 起始位置

#include #include int main(){	int* p = (int*)malloc(10 * sizeof(int));	if (p == NULL)	{		return -1;	}	int i = 0;	for (i = 0; i < 10; i++)	{		*p++ = 1;	}	free(p);	p = NULL;	return 0;}

4.5、對同一塊動態內存多次釋放

int main(){	int* p = (int*)malloc(40);	if (p == NULL)	{		return -1;	}	free(p);	free(p); // err}int main(){	int* p = (int*)malloc(40);	if (p == NULL)	{		return -1;	}	free(p);	p = NULL;	free(p); // ok}

4.6、動態開辟內存忘記釋放（內存泄漏）

在堆區上申請空間，有2種回收方式，

1. free
2. 程序退出時，申請的空間回收

int main(){	int* p = (int*)malloc(40);	if (p == NULL)	{		return -1;	}	// 沒有釋放	return 0;}

三、經典筆試題

題目一：

#include #include void GetMemory(char* p){	p = (char*)malloc(100);} void Test(void){	char* str = NULL;	GetMemory(str); 	strcpy(str, "hello world");	printf(str);} int main(){	Test();	return 0;}

程序會崩潰

1. str傳給p的時候，是值傳遞，p是str的臨時拷貝，所以當malloc開辟的空間起始地址放在p中時，不會影響str，str仍是NULL
2. 當str是NULL，strcpy想把hello world拷貝到str指向的空間時，程序就會崩潰，因為NULL指針指向的空間時不能直接訪問的
3. 存在內存泄漏，出函數銷毀，無法回收空間

修改：
版本1：

#include #include #include void GetMemory(char** p){	*p = (char*)malloc(100);} void Test(void){	char* str = NULL;	GetMemory(&str); // char** 	strcpy(str, "hello world");	printf(str);	// 釋放	free(str);	str = NULL;} int main(){	Test();	return 0;}

版本2：

#include #include #include char* GetMemory(char* p){	p = (char*)malloc(100); 	return p;} void Test(void){	char* str = NULL; 	str = GetMemory(str);	strcpy(str, "hello world"); 	printf(str);		free(str);	str = NULL;} int main(){	Test();	return 0;}

題目二：

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

【返回棧空間地址問題】

#include int* test(){	int n = 10;	return &n;} int main(){	int* p = test();	printf("%d/n", *p);	// 如果沒有被覆蓋,有可能輸出10		return 0;}

題目三：

#include 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(){	Test();	return 0;}

通過*p 用malloc給str在堆上開辟空間，
問題：

內存泄漏，沒有free
free(str);
str = NULL;

改正：

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

題目四：

#include #include 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;}

改正：

#include #include void Test(void){	char* str = (char*)malloc(100);	strcpy(str, "hello");	free(str);	str = NULL;	if (str != NULL)	{		strcpy(str, "world");		printf(str);	}}int main(){	Test();	return 0;}

四、C/C++程序的內存開辟

五、柔性數組

1、柔性數組成員

C99 中，結構中的最后一個元素允許是未知大小的數組，這就叫做『柔性數組』成員。

// 數組大小不確定，可大可小typedef struct st_type{	int i;	int a[0];//柔性數組成員}type_a;// 編譯器報錯無法編譯可改成：typedef struct st_type{	int i;	int a[];//柔性數組成員}type_a;

2、柔性數組的特點：

1. 結構中的柔性數組成員前面必須至少一個其他成員	如 int a[] 前有 int i2. sizeof 返回的這種結構大小不包括柔性數組的內存

#include typedef struct <