1.为什么有动态内存管理
int a=20;//开辟4个字节
int arr[10]={0};//开辟40个字节
上述的代码有两个特点
1.开辟空间的大小是固定的。
2.数组在申明的时候已经固定了大小，无法更改。
这样写代码不够灵活，所以c语言中引入了动态内存管理，让程序员可以自己申请和释放空间，这样可以灵活一点。
2.malloc和free
malloc和free的头文件均为stdlib.h
2.1malloc
一个动态内存开辟函数
void*malloc (size_t size)
malloc可以申请一片连续 的空间，并返回开辟空间的首地址 。
1.开辟成功，返回这片连续空间的首地址。
2.开辟失败，返回NULL指针。例:INT_MAX
3.返回类型是void*，所以开辟空间的类型可以根据使用者自由决定。
4.size是字节数。
2.2free
free是用来释放和回收动态内存管理开辟的空间的。
void free （void*ptr）
1.如果ptr指向的空间不是动态开辟的，那么free的行为是未定义的
2.如果ptr是NULL，则函数什么都不做。
#include <stdio.h>
#include<stdlib.h>
int main()
{
int* ptr = NULL;
ptr = (int*)malloc(10 * sizeof(int));//开辟空间
if (NULL != ptr)//判断ptr指针是否为空
{
int i = 0;
for (i = 0; i < 10; i++)
{
*(ptr + i) = 0;
}
}
free(ptr);//释放ptr所指向的动态内存
ptr = NULL;
return 0;
}
3.calloc和realloc
3.1calloc
calloc也可以来开辟空间。
void* calloc (size_t num, size_t size);
calloc的功能为开辟num个大小为size的一块空间，并且把空间的每个字节都初始化为0.
int main()
{
//申请10个连续的整形空间；
//malloc(10*sizeof(int))
int* p = (int*)calloc(10, sizeof(int));
if (p == NULL)
{
perror("calloc");
return 1;
}
//使用
for (int i = 0; i < 10; i++)
{
printf("%d ", p[i]);//打印出10个0。
}
//释放
free(p);
p = NULL;
return 0;
}
calloc和malloc没什么区别，只是calloc会把申请的字节都初始化为0.
3.2realloc
这个函数可以使我们开辟后的空间可以改变。
void* realloc (void* ptr, size_t size);
ptr：要调整的内存地址
size：把该地址改为多大的空间
返回值为改变之后的起始地址
realloc函数在扩容空间的时候，扩容成功有两种情况
情况1.后面有充足的空间，把后面的空间直接分配给你。
情况2.后面的空间不足
1.直接在堆区找一块新的满足大小的空间
2.将旧的数据，拷贝到新的地址当中
3.将旧空间释放
4.返回新的地址
int main()
{
//申请10个连续的整形空间；
//malloc(10*sizeof(int))
int* p = (int*)calloc(10, sizeof(int));
if (p == NULL)
{
perror("calloc");
return 1;
}
//使用
for (int i = 0; i < 10; i++)
{
printf("%d ", p[i]);
}
//调整为20个整形空间
//用新的指针接收，这样开辟失败也不会丢失p指向的内容
int* ptr = (int*)realloc(p, 20 * sizeof(int));
if (ptr != NULL)
{
p = ptr;
}
//使用
//。。。
//释放
free(p);
p = NULL;
return 0;
}
4.常见的动态内存的错误
4.1对NULL指针的解引用操作
就是没有开辟成功空间，返回NULL地址，又去解引用它。
int main()
{
int* p = (int*)malloc(sizeof(INT_MAX));
//使用
*p = 10;
//释放
free(p);
p = NULL;
return 0;
}
4.2 对动态开辟空间的越界访问
int main()
{
//申请10个连续的整形空间；
//malloc(10*sizeof(int))
int* p = (int*)malloc(10*sizeof(int));
if (p == NULL)
{
perror("malloc");
return 1;
}
//使用
for (int i = 0; i < 40; i++)
{
p[i] = i + 1;//越界访问
}
free(p);
p = NULL;
return 0;
}
4.3 对非动态开辟内存使用free释放
int main()
{
int a = 10;
int* p = &a;
free(p);
}
free释放的是动态内存的空间。
4.4 使用free释放一块动态开辟内存的一部分
int main()
{
//申请10个连续的整形空间；
//malloc(10*sizeof(int))
int* p = (int*)malloc(10*sizeof(int));
if (p == NULL)
{
perror("malloc");
return 1;
}
//使用
for (int i = 0; i < 5; i++)
{
*(p++) = i + 1;
}
free(p);
p = NULL;
return 0;
}
p的地址被改变了，释放的是一部分
4.5 对同一块动态内存多次释放
int main()
{
//申请10个连续的整形空间；
//malloc(10*sizeof(int))
int* p = (int*)malloc(10 * sizeof(int));
if (p == NULL)
{
perror("malloc");
return 1;
}
//使用
for (int i = 0; i < 5; i++)
{
*(p++) = i + 1;
}
free(p);//第一次
//...
free(p);//第二次
p = NULL;
return 0;
}
p释放了两次，第二次相当于释放野指针了，会发生错误。如果第一次释放p之后把它置为NULL，则不会发生错误，就是逻辑上说不通。
4.6 动态开辟内存忘记释放（内存泄漏 ）
void test()
{
int* p = (int*)malloc(10 * sizeof(int));
int flag = 1;
if (p == NULL)
{
perror("malloc");
return 0;
}
//使用...
if (flag)
{
return 1;
}
free(p);
p = NULL;
}
int main()
{
test();
return 0;
}
这个test函数就没有释放，提前return了
5.动态内存笔试题分析
5.1对NULL解引用
void GetMemory(char* p)
{
p = (char*)malloc(100);//p开辟了一片空间，但是和str没有关系
//忘记free
}
void Test(void)
{
char* str = NULL;
GetMemory(str);//传值调用，非传址调用
strcpy(str, "hello world");//对str进行解引用操作，程序会奔溃
printf(str);//这个打印是没有问题的
}
int main()
{
Test();
return 0;
}
这个代码有两个错误
1.对str进行解引用操作，程序会奔溃
2.开辟的空间没有释放，内存会泄露
正确写法1
void GetMemory(char** p)
{
*p = (char*)malloc(100);
}
void Test(void)
{
char* str = NULL;
GetMemory(&str);
strcpy(str, "hello world");
printf(str);
free(str);
str = NULL;
}
int main()
{
Test();
return 0;
}
正确写法2
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;
}
开辟的空间可以返回地址
5.2返回栈空间地址的问题
char* GetMemory(void)
{
char p[] = "hello world";
return p;//返回指针，但是返回之后这个函数就销毁了，但是如果malloc开辟的空间就不会销毁，因为malloc释放的话得用free。
}
void Test(void)
{
char* str = NULL;
str = GetMemory();//str接收的是野指针，GetMemory不属于当前程序了
printf(str);//打印的时候可能被别人修改了
}
int main()
{
Test();
return 0;
}
返回栈空间的时候，接收变量没有问题，但是接收地址有问题 ，因为会销毁。
5.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);//可以打印，但是malloc开辟的内存需要释放
}
int main()
{
Test();
return 0;
}
正确写法
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;
}
5.4非法访问
void Test(void)
{
char* str = (char*)malloc(100);
strcpy(str, "hello");
free(str);//把malloc出来的空间还给操作系统，无法继续使用，str变为野指针
if (str != NULL)//ok
{
strcpy(str, "world");//非法访问
printf(str);
}
}
int main()
{
Test();
return 0;
}
正确写法
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;
}
6.柔性数组
6.1什么是柔性数组
1.在结构体中
2.最后一个成员
3.未知大小的数组
例如：
struct S
{
int a;
char n;
double b;
int arr[];//未知大小的数组，arr就是柔性数组成员
};
或者
struct S
{
int a;
char n;
double b;
int arr[0];//未知大小的数组，arr就是柔性数组成员
};
6.2柔性数组的特点
1.结构中的柔性数组成员前面必须至少一个 其他成员。
2.sizeof 返回的这种结构大小不包括柔性数组 的内存。
3.包含柔性数组成员 的结构用malloc ()函数进行内存的动态分配 ，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。
struct S
{
int a;
int arr[];
};
int main()
{
printf("%zd", sizeof(struct S));//结果为4
return 0;
}
struct S{
int a;
int arr[];
};
int main()
{
struct S*ps=(struct S*)malloc(sizeof(struct S) + 20 * sizeof(int));
if (ps == NULL)
{
perror("malloc");
return 1;
}
free(ps);
ps=NULL;
return 0;
}
6.3柔性数组的使用
struct S
{
int a;
int arr[];
};
int main()
{
struct S*ps=(struct S*)malloc(sizeof(struct S) + 20 * sizeof(int));
if (ps == NULL)
{
perror("malloc()");
return 1;
}
//使用这片空间
ps->a = 20;
for (int i = 0; i < 20; i++)
{
ps->arr[i] = i + 1;
}
free(ps);
ps=NULL;
return 0;
}
6.4柔性数组的大小改变
struct S
{
int a;
int arr[];
};
int main()
{
struct S* ps = (struct S*)malloc(sizeof(struct S) + 20 * sizeof(int));
if (ps == NULL)
{
perror("malloc()");
return 1;
}
//使用这片空间
ps->a = 20;
for (int i = 0; i < 20; i++)
{
ps->arr[i] = i + 1;
}
//改变柔性数组的大小
struct S* p = (struct S*)realloc(ps, (sizeof(struct S) + 40 * sizeof(int)));
if (p != NULL)
{
ps = p;
p = NULL;
}
else
{
perror("malloc");
return 1;
}
for (int i = 0; i < 40; i++)
{
printf("%d ", ps->arr[i]);
}
free(ps);
ps = NULL;
return 0;
}
或者
struct S
{
int a;
int* arr;
};
int main()
{
struct S* ps = (struct S*)malloc(sizeof(struct S));
if (ps == NULL)
{
perror("malloc");
return 1;
}
int* tmp = (int*)malloc(20 * sizeof(int));
if (tmp != NULL)
{
ps->arr=tmp;
}
else
{
perror("malloc");
return 1;
}
//给arr中的数赋值为1~20
for (int i = 0; i < 20; i++)
{
ps->arr[i] = i + 1;
}
//修改arr的大小
tmp=(int *)realloc(ps->arr, 40 * sizeof(int));
if (tmp != NULL)
{
ps->arr = tmp;
}
else
{
perror("malloc");
return 1;
}
for (int i = 0; i < 40; i++)
{
printf("%d ", ps->arr[i]);
}
//释放,先释放ps里面的arr，再释放ps
free(ps->arr);
ps->arr = NULL;
free(ps);
ps = NULL;
return 0;
}
代码1和代码2均能实现同样的功能，但代码1更好一些，因为代码1malloc的次数少，减少的内存碎片，因为malloc开辟的空间是连续的，开辟的多中间空的间隙也多。
7，总结c/c++中程序内存区域划分
