如何分配C語言編程C++動態內存

本篇內容主要講解“如何分配C語言編程C++動態內存”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實用性強。下面就讓小編來帶大家學習“如何分配C語言編程C++動態內存”吧!

目錄

• 動態內存管理

• 為什么存在動態內存分配

• 動態內存函數的介紹

• malloc申請空間和free釋放空間

• 有借有還free釋放內存

• calloc申請內存

• realloc調整動態內存的大小

• realloc使用的注意事項

• 當然realloc也可以直接開辟空間

• 常見的動態內存錯誤

• 1.對NULL指針的解引用操作

• 2.對動態開辟空間的越界訪問

• 3.對非動態開辟內存使用free釋放

• 4.使用free釋放一塊動態內存開辟的一部分

• 5.對同一塊動態內存多次釋放

• 6.動態開辟內存忘記釋放(內存泄漏)

• 幾個面試題

• 題目1

• 題目2

• 題目3

• 題目4

• C/C++程序的內存開辟

• C/C++程序內存分配的幾個區域：

動態內存管理

為什么存在動態內存分配

我們到現在為止掌握的是什么樣的內存開辟方式呢

//創建一個變量
int val = 20;    //局部變量  在棧空間中開辟4個字節
int g_val = 10;  //全局變量  在靜態區中開辟4個字節
//創建一個數組
char arr[10] = {0}; //局部區域 在棧空間中開辟10個字節連續的空間
char g_arr[5] = {0};//全局區域 在靜態區空間中開辟5個字節的連續空間

但是上述的開辟空間的方式有兩個特點：

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

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

c99是支持變長數組的，但現在很多編譯器就不支持c99，連vs都不支持，所以就有動態內存的概念

動態內存函數的介紹

malloc申請空間和free釋放空間

c語言提供了一個動態內存開辟的函數

void* malloc(size_t size);

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

1.如果開辟成功，則返回一個指向開辟好空間的指針。

2.如果開辟失敗，則返回一個NULL指針，因此malloc的返回值一定要做檢查。

3.返回值的類型是 void ，所以malloc函數并不知道開辟空間的類型，具體在使用的時候使用者自己來決定。*

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

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>
int main()
{
	//向內存申請10個整形的空間
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		//把開辟失敗的信息打印出來
		printf("%s",strerror(errno));
	}
	else
	{
		//正常使用空間
		int i = 0;
		for (i = 0; i < 10; i++)
		{
			*(p + i) = i;//在找下標為i的元素
		}
		for (i = 0; i < 10; i++)//再把每個元素打印出來
		{
			printf("%d ", *(p + i));
		}
	}
	return 0;
}

那我們可不可以看開辟失敗的呢

我們可以用INT_MAX（他是整形最大），一個超級大的數字

有借有還free釋放內存

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

注意

malloc和free是成對使用的，誰開辟誰釋放

calloc申請內存

在內存中開辟一個數組，把元素都改成零

函數的功能是為 num 個大小為 size 的元素開辟一塊空間，并且把空間的每個字節初始化為0。

與函數 malloc 的區別只在于 calloc 會在返回地址之前把申請的空間的每個字節初始化為全0

realloc調整動態內存的大小

當然我們可以申請空間，但會不會遇到申請的空間不夠了，想要增加一些些，大了想要去掉一些些

realloc使用的注意事項

1.如果p指向的空間之后有足夠的內存空間可以追加，則直接追加，后返回p

2.如果p指向的空間之后沒有足夠的內存空間可以追加，則realloc函數會重新找一塊新的內存區域，開辟一塊滿足需求的空間，并且把原來的內存中的數據拷貝回來，釋放舊的內存空間，最后返回新開辟的內存空間地址

3.但也有一個大問題，就是開辟INT_MAX，用新的變量ptr來接收realloc返回值

當然realloc也可以直接開辟空間

常見的動態內存錯誤

1.對NULL指針的解引用操作

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(40);//沒成功就會有大問題
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}
	free(p);
	p = NULL;
	return 0;
}

所以為了防止沒有開辟動態內存成功就需要做個判斷

2.對動態開辟空間的越界訪問

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

int main()
{
	int* p = (int*)malloc(5*sizeof(int));
	if (p == NULL)//這里我的確判斷有沒有開辟成功了
	{
		printf("%s", strerror(errno));
	}
	else
	{
		int i = 0;
		for (i = 0; i < 10; i++)//但是我這里訪問10個整型的空間
		{
			*(p + i) = i;
		}
	}	
	free(p);
	p = NULL;
	return 0;
}

3.對非動態開辟內存使用free釋放

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

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

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>
int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		return 0;//如果是空指針就直接返回，不干了
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*p++ = i;//這個++就是bug的地方
	}
	//回收空間
	free(p);
	p = NULL;
	return 0;
}

只要p不是指向申請的空間的首地址，其他地方都是錯的

5.對同一塊動態內存多次釋放

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>
int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		return 0;
	}
	//使用
	//釋放
	free(p);
	//...
	free(p);
	return 0;
}

6.動態開辟內存忘記釋放(內存泄漏)

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>
int main()
{
	while (1)
	{
		malloc(100);
	}
	return 0;
}

幾個面試題

題目1

void GetMemory(char* p)
{
	p = (char*)malloc(100);
}
void Test(void)
{
	char* str = NULL;
	GetMemory(str);
	strcpy(str,"hello world");
	printf(str);//這個寫法和printf("%s",str);是一樣的
}
int main()
{
	Test();
	return 0;
}

問運行Test函數會有什么樣的結果

修改正確

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>
void GetMemory(char* *p)
{
	*p = (char*)malloc(100);
}
void Test(void)
{
	char* str = NULL;
	GetMemory(&str);
	strcpy(str,"hello world");	
	printf(str);//這個寫法和printf("%s",str);是一樣的
	free(str);//用完就釋放
	str = NULL;
}
int main()
{
	Test();
	return 0;
}

題目2

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

請問運行Test 函數會有什么樣的結果

輸出隨機值

修改正確

既然是p被銷毀了，那我們讓他不銷毀就可以了延長它的生命周期用static

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

題目3

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

這題基本和第一題一樣，不過這題就只有內存泄漏的錯誤

修改正確

#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);
	free(str);//用完就釋放，防止內存泄漏
	str = NULL;
}
int main()
{
	Test();
	return 0;
}

題目4

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

問題非常大的打印出結果

修改正確

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

void Test(void)
{
	char* str = (char*)malloc(100);
	strcpy(str, "hello");
	free(str);//這里考查的是free釋放后并沒有使str為NULL，所以下面if判斷就沒有作用，如果使他有作用就讓str為NULL
	str = NULL;
	if (str != NULL)
	{
		strcpy(str, "world");
		printf(str);
	}
}
int main()
{
	Test();
	return 0;
}

這道題真正目的就是讓你什么都不打印

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

C/C++程序內存分配的幾個區域：

棧區（stack）：在執行函數時，函數內局部變量的存儲單元都可以在棧上創建，函數執行結束時這些存儲單元自動被釋放。棧內存分配運算內置于處理器的指令集中，效率很高，但是分配的內存容量有限。 棧區主要存放運行函數而分配的局部變量、函數參數、返回數據、返回地址等。

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

數據段（靜態區）（static）存放全局變量、靜態數據。程序結束后由系統釋放。

代碼段：存放函數體（類成員函數和全局函數）的二進制代碼。

到此，相信大家對“如何分配C語言編程C++動態內存”有了更深的了解，不妨來實際操作一番吧！這里是億速云網站，更多相關內容可以進入相關頻道進行查詢，關注我們，繼續學習！