前言：

        在前面我们已经学习动态分配内存，今天我们就来做一做它的几道经典例题，加深巩固我们所学的知识。

知识复习：动态内存管理（1）_从前慢，现在也慢的博客-CSDN博客

---

题目1：

        下面代码存在什么问题，请你指出问题并修改。

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

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、程序从main开始，运行之后调用Test函数；

        2、进入Test函数，①先创建了一个str的字符指针，并赋初值为NULL；②调用GetMemory函数，以值传递的方式将str传给GetMemory（值传递，形参只是实参的一份临时拷贝，形参的改变不影响实参）；

        3、进入GetMemory函数，①p的初始值为NULL（值传递）；②malloc在堆区申请开辟100个字节的连续空间，并将malloc的返回值赋值给p（①忘记判断malloc是否开辟成功；②没有自己free释放申请的动态内存，如果程序一直运行造成内存泄漏）；因为函数类型是void，所以代码执行完，直接返回到test函数中的GetMemory调用；

        4、GetMemory调用完继续向下执行，调用strcpy函数，但是目标空间的实参为NULL（值传递形参不影响实参），造成了strcpy形参的非法访问，所以程序出错，不再向下执行。

图示：

问题归纳：

问题1： 

       GetMemory是传值调用，str传给p的时候，p是str的临时拷贝，有自己独立的空间，当GetMemory函数内部申请完空间后，申请空间的起始地址放在p中，str依然是NULL。当GetMemory函数返回之后。执行strcpy函数拷贝时，strcpy的目标空间形参为NULL，造成非法访问内存。

解决方案：

        ①传址调用（形参影响实参）；②通过函数返回值得到。

问题2：

        GetMemory函数内部只动态申请了内存，在Test函数中使用，①但是并没有将malloc的返回值传给Test，②在使用动态内存前没有判断开辟是否成功，③使用完并没有释放空间，如果程序一直运行，会内存泄漏。

解决方案：

        ①使用动态开辟的内存前，判断是否开辟成功；②使用完之后记得free释放。

代码修改1： 通过传址调用，可以间接的得到malloc开辟空间的起始地址，使用前判断是否开辟成功，使用完记得释放

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

//GetMemory内部进行了malloc操作，在Test函数中使用这块空间，
//通过地址传递，可以得到malloc开辟空间的起始地址，记得在Test函数释放
void GetMemory(char** p)
{
	*p = (char*)malloc(100);
}

void Test(void)
{
	char* str = NULL;
	//调用GetMemory，动态开辟100个字节的空间(传址调用，形参影响实参)
	GetMemory(&str);
	//判断malloc是否开辟成功
	if (NULL == str)
	{
		//开辟失败，打印错误信息，并退出
		perror("malloc");
		return ;
	}
	//将hello world拷贝到malloc开辟的空间
	strcpy(str, "hello world");
	//打印拷贝后的内容
	printf(str);
	//使用完动态开辟的内存，free释放
	free(str);
	//free不会改变str的值，防止非法访问内存，将其设置为NULL
	str = NULL;
}

int main()
{
	Test();
	return 0;
}

代码修改2：通过函数的返回值得到malloc开辟空间的起始地址，使用完记得释放

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

//GetMemory内部进行了malloc操作，在Test函数中使用这块空间，
//通过返回其malloc的返回值可以得到malloc开辟空间的起始地址，记得在Test函数释放
char* GetMemory()
{
	char* p = (char*)malloc(100);
	return p;
}

void Test(void)
{
	char* str = NULL;
	//调用GetMemory，动态开辟100个字节的空间
	str = GetMemory();
	//判断malloc是否开辟成功
	if (NULL == str)
	{
		//开辟失败，打印错误信息，并退出
		perror("malloc");
		return;
	}
	//将hello world拷贝到malloc开辟的空间
	strcpy(str, "hello world");
	//打印拷贝后的内容
	printf(str);
	//使用完动态开辟的内存，free释放
	free(str);
	//free不会改变str的值，防止非法访问内存，将其设置为NULL
	str = NULL;
}

int main()
{
	Test();
	return 0;
}

题目2：

        下面代码存在什么问题，请你指出问题并修改。

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

运行结果：

打印结果为什么不是hello world呢？（小知识：0xcccc打印就是烫）

分析：

        1、程序从main开始，运行之后调用Test函数；

        2、进入Test函数，①先创建一个字符指针变量str，并赋初值为NULL；②调用GetMemory函数，（因为形参为void，所以不传参），将其返回值赋值给str；

        3、进入GetMemory函数，定义了一个局部变量的数组（因为在栈区申请的空间），返回数组的数组名，即返回数组首元素地址（因为数组在该函数的函数栈帧创建，函数执行结束后会自动释放，所以返回了的数组首元素地址已经没有意义了，再通过该地址去访问空间就会造成非法访问内存问题。）；函数执行完，直接回到Test函数中的GetMemory调用。

        4、GetMemory调用完将返回值赋值给str，继续向下执行，调用printf，但是传的实参str指向的那块空间已经还给操作系统，所以造成非法访问内存，打印的就是烫烫……

图示：

问题归纳：

问题：

        return语句不可返回指向“栈内存”的“指针”或者“引用”，因为该内存在函数体结束时被自动销毁。（自动销毁就是把空间还给操作系统，空间返回给了操作系统，再使用空间就会造成非法访问内存，所以返回的指针或者引用就没有实际意义了。）。

解决方案：

        1、将局部变量改存在静态区（存在静态区的数据，创建好后，直到程序结束才释放）：

               （1）关键字static修饰局部变量，被static修饰的局部变量，改变了局部变量的存放位置，静态局部变量存放在静态区。

                （2）使用字符指针指向常量字符串，常量字符串存储在静态区。

        2、将局部变量拷贝到堆区（存在堆区的数据，创建好后，①程序结束后系统回收；②free自己回收） 

代码修改1：关键字static修饰局部变量

#include<stdio.h>

//创建一个静态局部数组变量，返回其首地址
char* GetMemory(void)
{
	//静态局部变量：存放在静态区，它的生命周期变长，直到程序结束才释放
	static char p[] = "hello world";
	//返回字符串的首地址
	return p;
}

void Test(void)
{
	char* str = NULL;
	//调用GetMemory函数，得到字符串的首地址
	str = GetMemory();
	//打印字符串
	printf(str);
}

int main()
{
	Test();
	return 0;
}

代码修改2：使用字符指针指向常量字符串

#include<stdio.h>

//创建一个常量字符指针，指向一个常量字符串，返回这个字符指针
const char* GetMemory(void)
{
	//常量字符串存储在静态区，直到程序结束才释放
	//常量字符串出现在表达式中，这个常量字符串的值就是首字符的地址
	const char* p = "hello world";
	//返回字符串的首地址
	return p;
}

void Test(void)
{
	const char* str = NULL;
	//调用GetMemory函数，得到字符串的首地址
	str = GetMemory();
	//打印字符串
	printf(str);
}

int main()
{
	Test();
	return 0;
}

代码修改3：将局部变量拷贝到堆区

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

//GetMemory内部进行malloc操作，并赋初值“hello world”，之后在Test中打印
//通过返回其malloc的返回值得到“hello world”的首地址，记得在Test中释放
char* GetMemory(void)
{
	
	char p[] = "hello world";
	//计算数组p的大小
	int sz = sizeof(p);
	//开辟sz个字节的空间
	char* ptr = (char*)malloc(sz);
	//判断是否开辟成功
	if (NULL == ptr)
	{
		//打印错误信息
		perror("malloc");
		exit(0);
	}
	//将数组p拷贝到动态内存中
	strcpy(ptr, p);
	//返回malloc的返回值
	return ptr;
}

void Test(void)
{
	char* str = NULL;
	//调用GetMemory函数，得到malloc的返回值
	str = GetMemory();
	//打印字符串
	printf(str);
	//释放
	free(str);
	str = NULL;
}

int main()
{
	Test();
	return 0;
}

题目3：

        下面代码存在什么问题，请你指出问题并修改。

#include<stdio.h>
#include<stdlib.h>
#include<string.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()
{
	Test();
	return 0;
}

分析：

        1、程序从main开始，运行之后调用Test函数；

        2、进入Test函数，①先创建一个字符指针变量str并为其赋初值为NULL；②调用GetMemory函数第一个参数为地址传递（形参影响实参，解引用可以间接操控实参，得到开辟空间的起始地址），第二个参数为值传递（形参不影响实参，决定开辟空间的大小）；

        3、进入GetMemory函数，GetMemory函数内部开辟好空间，在Test中使用开辟的空间，记得释放，因为函数类型为void，所以执行完之后直接回到Test函数中的GetMemory调用；

        4、GetMemory调用完，继续向下执行，①调用strcpy将“hello”拷贝到malloc开辟的空间（使用malloc开辟的空间前完了判断是否开辟成功）；②调用printf打印开辟空间的内容，打印完后直接回到main函数中（忘记使用完动态空间之后，free释放，如果程序一直运行，内存泄漏）。

问题归纳：

问题1：

        动态开辟的空间，使用前，忘记判断是否开辟成功，造成非法访问。

解决方案：

        使用前使用if语句判断其返回值是否为空指针。

问题2：

        动态开辟的空间，忘记了释放内存（如果程序一直运行），造成内存泄漏。

解决方案：

        1、动态内存的申请与释放必须配对，程序中malloc与free的使用次数一定要相同，否则就会有错误。（使用完动态开辟的内存使用完一定要释放，并且释放完还要将指针设置为NULL，防止非法访问内存。）。

        2、使用动态开辟的空间，最好注释空间是否释放

代码修改：

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

//GetMemory函数通过第一个参数间接返回开辟空间的地址，
// 通过第二个参数确定开辟空间的大小。
// 在GetMemory函数内部创建好空间，在Test中使用，记得释放空间
void GetMemory(char** p, int num)
{
	*p = (char*)malloc(num);
}

void Test(void)
{
	char* str = NULL;
	GetMemory(&str, 100);
	//判断malloc是否开辟成功
	if (NULL == str)
	{
		return;
	}
	//使用
	strcpy(str, "hello");
	printf(str);
	//释放
	free(str);
	str = NULL;
}

int main()
{
	Test();
	return 0;
}

题目4：

        下面代码存在什么问题，请你指出问题并修改。

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

分析：

        1、从main开始，运行后调用Test函数；

        2、进入Test函数，①malloc动态申请100个字节的空间，并将返回值赋给str；②调用strcpy函数将“hello”拷贝到动态申请的空间中（使用前未判断malloc是否申请空间成功）；③使用完free释放malloc的空间（free释放完空间之后，不会改变指针str的值，未将其设置为NULL，后面使用到str还能找到释放的那块空间，造成非法访问内存）；④free释放完，str的值不为空，条件为真，执行if控制的语句，调用strcpy和printf，使用到了已经释放的空间，造成非法访问空间。

问题归纳：

问题1：

        动态开辟的空间，使用前，忘记判断是否开辟成功，造成非法访问。

解决方案：

        使用前使用if语句判断其返回值是否为空指针。

问题2：

        free释放了内存，却仍然继续使用它（free释放完内存，不会改变指针的指向），造成非法访问内存。

解决方案：

        free释放完内存，将指针设置为NULL，防止非法访问内存。

代码修改：

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

void Test(void)
{
	char* str = (char*)malloc(100);
	//使用前判断是否开辟成功
	if (NULL == str)
	{
		return;
	}
	//使用
	strcpy(str, "hello");
	//释放
	free(str);
	//free释放并不会改变指针指向，防止非法访问内存，将其设置为NULL
	str = NULL;
	if (str != NULL)
	{
		strcpy(str, "world");
		printf(str);
	}
}

int main()
{
	Test();
	return 0;
}

---

加油站：C/C++程序内存分配的区域：

内存图：

C/C++程序内存分配的几个区域：

        1、栈区 （stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中。效率很高，但是分配的内存容量有限。栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。

        2、堆区（heap）：动态内存分配。一般由程序员分配释放，生存期由我们决定，非常灵活，但问题也最多。若程序员自己不释放，程序结束时可能由OS回收。分配方式类似于链表。

        3、数据段（静态区）：内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在，程序结束后由系统释放。例如全局变量、static变量。

        4、代码段（静态区）：存放函数体（类成员函数和全局函数）的二进制代码。也可能包含一些只读的常数变量，如常量字符串。

在之前我们就学过了static关键字修饰的局部变量，现在我们重新回顾：

        1、普通的局部变量是放在栈区上的，这种局部变量进入作用域创建，出了作用域释放。

        2、但是局部变量被static修饰后，这种变量就放在静态区，放在静态区的变量，创建好后，直到程序结束才释放。

       3、本质上：static的修改改变了局部变量的存储位置，因为存储位置的差异，使得执行效果不一样。

        注意：被static修饰是不影响作用域的！！！但是生命周期发生了变化，变长了。

1、栈区：变量空间进入作用域创建，出作用域就释放。

2、堆区：变量空间由程序员自己决定，或者程序结束由系统回收。

3、静态区：变量空间创建好之后，直到程序结束才释放。