动态内存管理2

我们开辟的动态内存空间，程序结束就会自动释放，但工作后做出的程序可能会7*24持续运行，不手动释放不需要的内存可能会造成内存泄漏。

常见的动态内存错误

1.对null指针的解引用

int main()
{
	int* p = (int*)malloc(20);
	//没判断是否为空直接对p进行接引用操作，
	//如果返回的是空程序会直接崩掉。
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		p[i] = i + 1;
	}
	free(p);
	p = NULL;
	return 0;
}

2.对动态开辟空间的越界访问

int main()
{
	int* p = malloc(10);
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return 0;
	}
	int i = 0;
	for (i = 0; i < 10; i++)//空间不足，越界访问
	{
		p[i] = i + 1;
	}
	free(p);//在此情况下释放内存，程序会直接崩掉。
	p = NULL;
	return 0;
}

3.对非动态开辟内存使用free释放

int main()
{
	int pa[10] = { 0 };
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		pa[i] = i + 1;
	}
	free(pa);//pa是非动态内存开辟的空间，释放会直接崩掉。
	return 0;
}

4.使用free释放一块动态开辟内存的一部分

int main()
{
	int* pa = (int*)malloc(40);
	
	if (pa == NULL)
	{
		printf("%s\n", strerror(errno));
		return 0;
	}
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*pa = i+1;
		pa++;
	//改变了pa,pa已经不指向开辟空间的起始地址了,直接对pa进行释放是十分危险的行为。
	}
	free(pa);
	pa = NULL;
	return 0;
}

5.对同一块动态内存多次释放

int main()
{
	int* pa = (int*)malloc(20);
	if (pa == NULL)
	{
		printf("%s\n", strerror(errno));
		return 0;
	}
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		pa[i] = i + 1;
	}
	free(pa);
	//free(pa);//再次释放程序会出错。
	pa = NULL;
	free(pa);//因为free不会对空指针进行操作，所以把指针置空后再次释放不会报错。
	//体现了释放内存后立即对指针置零的重要性。
	return 0;
}

6.动态开辟内存忘记释放（内存泄漏）

void tst(void)
{
	int* pa = (int*)calloc(5, sizeof(int));
	if (pa == NULL)
	{
		printf("%s\n", strerror(errno));
		return;
	}
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		pa[i] = i + 1;
	}
}//pa是创建的临时变量，出了该函数直接销毁，
//但calloc创建的空间不会。
int main()
{
	tst();
	free(pa);//这里pa没有任何信息。
	pa == NULL;
	return 0;
}

几个经典的笔试题（改错）

1.

void GetMemory(char* pa)
{
	pa = (char*)malloc(30);
}
void Test()
{
	char* str = NULL;
	GetMemory(str);
	strcpy(str, "hello");
	printf(str);
}
int main()
{
	Test();
	return 0;
}

改进 1

void GetMemory(char**pa)//二级指针接收
{
	*pa = (char*)malloc(30);
}

void Test()
{
	char* str = NULL;
	//传址
	GetMemory(&str);
	strcpy(str, "hello");
	printf(str);
	free(str);
	str = NULL;
}
int main()
{
	Test();
	return 0;
}

改进2

char* GetMemory(void)
{
	char* pa = (char*)malloc(30);
	return pa;//返回pa
}
void Test()
{
	char* str = NULL;
	//传址
	str=GetMemory();
	strcpy(str, "hello");
	printf(str);
	free(str);
	str = NULL;
}
int main()
{
	Test();
	return 0;
}

上面的程序中有printf(str),其实printf（）内有地址就行：print发（"hallo"）中"hallo"这个表达式其实也是这个字符串的起始地址。

2.

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

错处：

int* f2(void)
{
	int* ptr;
	*ptr = 10;
	return ptr;
}

错因：ptr还未初始化就直接引用，此时ptr是野指针，造成非法访问的问题。

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

错因：没用free释放内存，造成内存泄漏。

4.

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

错因：free之后没有置空，造成之后的程序非法访问。