动态内存管理

2.malloc和free

3.calloc和realloc

4.常见的内存错误

5. 动态内存经典笔试题分析

6.柔性数组

7.总结C/C++z中内存的划分

8.总结C/C++中内存区域划分

1.为什么要有动态内存管理

前面的学习中，我们已经知道，内存的申请已经有下面的几种方式

int a=20;//在栈区上面开辟一个变量

char b='a';

int arr[10]=0;//在栈区上面开辟一块连续的内存

但是上面的内存开辟，有几个特点

1.空间开辟的内存是固定的

2.在定义数组的时候，必须要写出数组的长度

比如

int arr[30]=0;//用于存放学生的成绩

但是当学生的人数变了的话，这块内存就无法使用了

对于内存的使用，不只是上述的情况，有些程序的空间只有在运行的时候才能知道，所以C语言给出了动态内存开辟，让程序员自己开辟和释放内存，这样就比较灵活了

2.malloc和free

malloc和free

void* malloc (size_t size);//该函数返回的是该块内存的首地址,开辟多少个内存的空间

注意：1.如果开辟空间成功，就会返回该空间的首元素的地址

            2.如果开辟失败，就会返回一个空指针，因此一定要做检查，检查语句

if（ptr==NULL)
{
    retunr 1;
}

          3.返回的值是void*，具体要什么类型，由编译者自己决定，使用时只需要强制类型转换一下

        4.malloc申请是在函数的堆区

void free(void*ptr)//ptr，该块内存的首地址

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(40);//在这里可以强强制类型转换一下
	//程序员知道自己应该用它来存储什么样的数据
	if (p == NULL)
	{
		perror("malloc");//打印出错误码
	}
	for (int i = 0; i < 10; i++)
	{
		*(p + i) = i;//malloc函数的使用
	}
	free(p);//释放内存,但是p的内存不会置于0，还是原来的地址
	p = NULL;//赋值成为空指针，避免成为野指针
	return 0;
}

3.calloc和realloc

void*calloc(int num,size_t size),申请一块内存数为num个，每个得大小为size，并且把每个内存的地址初始化为0

1.该函数与malloc函数的唯一区别是把内存初始化为0

#include<stdlib.h>
int main()
{
	int* ptr1 = (int*)malloc(5 * sizeof(int));
	int* ptr2 = (int *)calloc(5, 4);
	for (int i = 0; i < 5; i++)
	{
		printf("%d ", *(ptr1 + i));
		
	}
	printf("\n");
	for (int i = 0; i < 5; i++)
	{
		printf("%d ", *(ptr2 + i));
		
	}
	return 0;
}

输出的结果为：第一行为随机值，第二行全为0

realloc

void* realloc (void* ptr, size_t size)

1.将原来的空间调为size大小，ptr是原来空间的首地址

2，将ptr置为NULL，功能就和malloc一样了

3，函数调整空间失败，返回NULL，所以在在接收函数的返回值的时候，要用一个新的指针去判断，不是空指针的时候，才把新的指针赋给值p

4.函数调整空间成功，有下面的两种情况

（1）在已经开辟好的空间后面，没有足够的空间，函数会在后面重新申请一块足够空间，同时把旧的空间拷贝过去，返回新的空间的首地址，

（2）在已经开辟好的空间的后面，如果有足够，直接开辟

举例

#include<stdio.h>
int main()
{
	int* p = (int*)malloc(5 * sizeof(int));//在堆区上面申请一块20个字节的内存
	int* ptr = (int*)realloc(p, 10 * sizeof(int));//调整空间的大小为40个字节，用新的指针去接收，如果用p去，一旦失败，原来的空间会变没有
	if (ptr == NULL)
	{
		perror("realloc");
	}
	p = ptr;
	//使用部分，自行写代码
	free(p);//释放内存
	p = NULL;//手动置为空指针，防止成为野指针
	return 0;
}

4，常见的内存错误

1.对NULL指针进行解引用操作

#include<stdio.h>

int main()

{

        int*p=(int*)malloc(5*sizeof(int));

        *p=20;//可能是空指针

        free（p）；

        p=NULL;

        return 0;

}

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

int main()

{

        int *p=(int*)malloc(10*sizeof(int));

        if（p==NULL)

        {

        return 1;

        }

        for(int i=0;i<=10;i++)

        {

        *(p+i)=i;//当循环到第11次的时候，越界访问了

        }

        free(p);

        p=NULL;

        return 0;

}

3.对非动态内存进行释放

int a=10;

int *p=&a;

free(p);

4.使用free函数释放内存的一部分

int *p=(int *)malloc(10*sizeof(int));

p++;

free(p);//p现在指向的不是该块内存的首地址了

5.对同一块内存进行多次释放

int *p=(int *)malloc(10*sizeof(int));

p++;

free(p);

free（p);多次释放

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

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

 }
int main()
{
        test();//没有对内存进行释放
        while(1);
}

5.动态内存笔试题分析

第一题

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是两块独立的内存空间，无法将malloc开辟的空间放在str中，str为空指针

        2.程序使用了strcpy函数，是对空指针进行解引用操作

        3.没有释放内存，存在内存泄露

第二题

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

分析：1.该函数返回的p是首地址，就只返回了首地址，p空间已经出了函数，空间已经被销毁，返回的是p变成野指针

        2.存在内存泄露问题

第三题

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

}

分析：存在内存泄露问题

void Test(void)
{
        char *str = (char *) malloc(100);
        strcpy(str, "hello");
        free(str);//已经把str置为野指针，下面使用strcpy函数非法访问
if(str != NULL)
{
        strcpy(str, "world");
        printf(str);
}
}

6.柔性数组

柔性数组：在C99中，结构体的最后一个一个成员是一个未知大小的数组，这个数组被称为柔性数组，比如

struct st

{

        int i;

        char j;

        int arr[0];//数组的大小不知道

};

在有些编译器上面，这个可能会报错，也可以写成下面的形式

struct st

{

        int i;

        char j;

        int arr[];

};

柔性数组的特点

1.结构中的柔性数组成员前⾯必须⾄少⼀个其他成员。

2.sizeof返回的这种结构⼤⼩不包括柔性数组的内存

3.包含柔性数组成员的结构⽤malloc?()函数进⾏内存的动态分配，并且分配的内存应该⼤于结构的⼤⼩，以适应柔性数组的预期⼤⼩。

比如下面的代码

struct stu
{
    char a;
    int i;
    int arr[];
};
int main()
{
    printf("%d",sizeof(struct stu));
    return 0;
}//输出的结果是8，不算柔性数组的大小

柔性数组的使用

#include<stdio.h>
struct stu
{
	int a;
	char b;
	int arr[0];
};
int main()
{
	//struct stu s;//这里不能够用这种方式声明结构体，否者这里面没有柔性数组、要用下面的方式
	struct stu* p = (struct stu*)malloc(10 * sizeof(struct stu) + 10 * sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	p->a = 10;
	p->b='a';
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		p->arr[i] = i;
	}
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", p->arr[i]);
	}
	free(p);
	p = NULL;
	return 0;
}

也可以用下面的方式

struct stu
{
	int i;
	char j;
	int* arr;
};
int main()
{
	struct stu* pa = (struct stu*)malloc(sizeof(struct stu));
	if (pa == NULL)
	{
		return 1;
	}
	pa->i = 100;
	pa->j = 'a';
	//数组空间不够
	pa->arr = (int*)malloc(10* sizeof(int));
	if (pa->arr == NULL)
	{
		perror("realloc");
		return 1;
	}
	printf("%zd ", sizeof(struct stu));
	printf("\n");
	for (int i = 0; i  < 10; i++)
	{
		pa->arr[i] = i;
	}
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", pa->arr[i]);

	}
	free(pa->arr);
	pa->arr = NULL;
	free(pa);
	pa = NULL;

	return 0;
}

第⼀个好处是：⽅便内存释放
如果我们的代码是在⼀个给别⼈⽤的函数中，你在⾥⾯做了⼆次内存分配，并把整个结构体返回给⽤
⼾。⽤⼾调⽤free可以释放结构体，但是⽤⼾并不知道这个结构体内的成员也需要free，所以你不能
指望⽤⼾来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存⼀次性分配好了，并返
回给⽤⼾⼀个结构体指针，⽤⼾做⼀次free就可以把所有的内存也给释放掉。?
第⼆个好处是：这样有利于访问速度.?
连续的内存有益于提⾼访问速度，也有益于减少内存碎⽚。（其实，我个⼈觉得也没多⾼了，反正你
跑不了要⽤做偏移量的加法来寻址）

8.总结C/C++中内存区域划分

C/C++程序内存分配的⼏个区域：
1. 栈区（stack）：在执⾏函数时，函数内局部变量的存储单元都可以在栈上创建，函数执⾏结束时
这些存储单元⾃动被释放。栈内存分配运算内置于处理器的指令集中，效率很⾼，但是分配的内
存容量有限。?栈区主要存放运⾏函数⽽分配的局部变量、函数参数、返回数据、返回地址等。?
2. 堆区（heap）：⼀般由程序员分配释放，?若程序员不释放，程序结束时可能由OS回收?。分配⽅
式类似于链表。
3. 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。
4. 代码段：存放函数体（类成员函数和全局函数）的⼆进制代码