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. 代码段:存放函数体(类成员函数和全局函数)的⼆进制代码