C语言动态内存管理、柔性数组
C语言动态内存管理、柔性数组
为什么有动态内存管理
//没有动态内存分配之前我们掌握开辟的内存的方式有:
double a=10; //在栈上分配8个字节大小的空间
char ch[10]; //在栈上分配一段连续的空间
以上述方式开辟的内存有一下特点：
■ 空间开辟的大小是固定的
■ 数组在申明的时候，必须用一个常量来指定数组的长度，所需要的内存在编译时就已经在栈上分配好了
总结：在实际情况中我们对内存的需求，不止上述情况，有时我们需要的空间大小在程序运行的时候才能知道，那对于数组的定义上述方式就不能满足需求，这时就引入了动态内存分配。
C语言内存模型
对于C/C++的内存模型我在另外一篇博客作出了解释，博客传送门：C/C++内存模型
总：对于动态申请的内存都是在堆上分配的空间，由程序员手动管理，如果管理不当会造成严重的内存泄露的问题。
常用动态内存函数
malloc
函数原型：
void* malloc(size_t size);
说明：这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针，函数有一下特点：
■ 申请成功，返回指向开辟好的内存空间的指针，要注意强转
■ 申请失败，返回一个NULL指针,因此malloc的返回值一定要做检查
■ 返回值的类型是void*，所以malloc函数并不知道开辟空间的类型，具体在使用的时候由使用者自己来决定
■ 如果参数size为0，malloc的行为是标准是未定义的，取决于编译器
free
函数原型：
void free (void* ptr);
说明：函数free，专门用来做动态内存的释放和回收。该函数有一下特点：
■ 如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的
■ 如果参数 ptr 是NULL指针，则函数什么事都不做
■ 函数所释放的空间一定要是堆上分配的空间
【注意】
int main() {
int* p =(int *)malloc(sizeof(int) * 10);
free(p);//释放空间，释放之后p就是野指针
p = NULL;//释放指针
for (int i = 0; i < 10; i++) {
p[i] = i + 10;//非法操作
}
}
malloc与free正确使用的例子
int main()
{
//代码1
int num;
scanf("%d", &num);
//代码2
int* ptr = NULL;
ptr = (int*)malloc(num * sizeof(int));
memset(ptr,0,sizeof(int)*num);//初始化内存空间 可要可不要
if (NULL != ptr)//判断ptr申请空间是否成功
{
for (int i = 0; i < num; ++i)
{
*(ptr + i) = i;
}
for (int i = 0; i < num; ++i) {
printf("%d\n", ptr[i]);
}
}
free(ptr); //释放ptr所指向的动态内存
ptr = NULL;//将ptr值为NULL,释放指针，避免造成野指针
return 0;
}
calloc
函数原型：
void* calloc (size_t num, size_t size);
说明：calloc 函数也用来动态内存分配。以下特点：
■ 函数的功能是为num个大小为size 的元素开辟一块空间，并且把空间的每个字节初始化为0
■ 与函数malloc的区别只在于calloc会在返回地址之前把申请的空间的每个字节初始化为全0
int main()
{
int num;
scanf("%d", &num);
int* ptr1 = (int*)malloc(num * sizeof(int));
memset(ptr1,0,sizeof(int)*num);//这两句效果与calloc的效果是一致的
int* ptr2 = (int*)calloc(num,sizeof(int));
return 0;
}
realloc
函数原型：
void* realloc (void* ptr, size_t size);
说明：有时我们会发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了那 realloc 函数就可以做到对动态开辟内存大小的调整。以下特点：
■ ptr是要调整的内存地址，size调整之后新大小，若ptr=NULL，则退化为malloc函数
■ 返回值为调整之后的内存起始位置，如果申请空间不足则返回NULL
■ 函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间，调整空间分为3中情况
调整空间的情况：
常见的动态内存错误
■ 对NULL指针的解引用操作
void test()
{
int* p = (int*)malloc(INT_MAX);
*p = 20;//如果p的值是NULL，就会有问题
free(p);
}
■ 对动态开辟空间的越界访问
void test()
{
int i = 0;
int* p = (int*)malloc(10 * sizeof(int));
if (NULL == p)
{
exit(EXIT_FAILURE);
}
for (i = 0; i <= 10; i++)
{
*(p + i) = i; //当i是10的时候越界访问
}
free(p);
}
■ 对非动态开辟内存使用free释放
void test()
{
int a = 10;
int* p = &a;
free(p);// 错误,不能释放非动态内存开辟的内存
}
■ 使用free释放一块动态开辟内存的一部分
void test()
{
int* p = (int*)malloc(100);
p++;
free(p);//p不再指向动态内存的起始位置
}
■ 对同一块动态内存多次释放
void test()
{
int* p = (int*)malloc(100);
free(p);
free(p);//重复释放,但可以对NULL多次释放
}
■ 动态开辟内存忘记释放(内存泄漏)
void test()
{
int* p = (int*)malloc(100);
if (NULL != p)
{
*p = 20;
}
//没有释放p
}
int main()
{
test();
while (1);
}
忘记释放不再使用的动态开辟的空间会造成内存泄漏。 切记： 动态开辟的空间一定要释放，并且正确释放
【例题】
题目一
void GetMemory(char* p)
{
p = (char*)malloc(100);
}
void Test(void)
{
char* str = NULL;
GetMemory(str);
strcpy(str, "hello world");
printf(str);
}
//该题是传值调用要想操作str需要传二级指针，还有一个问题是没有释放str
void GetMemory(char** p)//str本身是一个地址所以应该传二级指针
{
*p = (char*)malloc(100);
}
void Test(void)
{
char* str = NULL;
GetMemory(&str); //应该传str的地址
strcpy(str, "hello world");
printf(str);
free(str); //在不用str后将str释放
str=NULL; //将str置空
}
题目二
char* GetMemory(void)
{
char p[] = "hello world";
return p;
}
void Test(void)
{
char* str = NULL;
str = GetMemory();
printf(str);
}
//运行Test函数会有怎样的结果
//在C/C++内存模型中提到：不要返回栈区分配的地址，栈区开辟的数据由编译器自动释放，所以只是返回了p的地址，p所指向的空间已经释放了
//修改:
char* GetMemory(void)
{
static char p[] = "hello world"; //static分配在全局区 ，该区的特点是该区域的数据在操作系统运行结束之后由操作系统释放。
return p;
}
void Test(void)
{
char* str = NULL;
str = GetMemory();
printf(str);
}
题目三
void Test(void)
{
char* str = (char*)malloc(100);
strcpy(str, "hello");
free(str); //释放之后str就是野指针，野指针不能使用
if (str != NULL)
{
strcpy(str, "world");
printf(str);
}
}
//当释放了指针之后我们应该将指针置空
void Test(void)
{
char* str = (char*)malloc(100);
strcpy(str, "hello");
free(str);
str=NULL;
if (str != NULL)
{
strcpy(str, "world");
printf(str);
}
}
柔性数组
概念： C99 中，结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员。
定义
typedef struct st_type{
int a;
int arr[0];//柔性数组
}st_type;
//有些编译器无法编译通过需要将改为
typedef struct st_type{
int a;
int arr[];//柔性数组
}st_type;
特点
■ 结构体中柔性数组成员前面至少有一个其他成员，且柔性数组只能是最后一个
■ 柔性数组不占空间，sizeof返回这种结构的大小不包括柔行数组内存
■ 包含柔性数组的成员的结构用malloc函数来进行内存分配，分配的空间要包括柔性数组预期的大小，所以分配的内存要大于结构的大小
例如
typedef struct st_type {
int a;
double c;
char st[0];
}st_type;
int main() {
st_type st;
printf("st的大小:%d",sizeof(st)); //16
return 0;
}
//输出16，需要考虑字节对齐，但是char st[0]柔性数组没有占空间
typedef struct Test {
int a;
double c;
char str[0];
}Test;
int main() {
char str[] = "Hello World";
Test *st=(Test*)malloc(sizeof(Test)+strlen(str)+1);//将柔性数组将要占用的空间考虑进去
if (st ==NULL) {
printf("memory error\n");
return -1;
}
strcpy(st->str, str);
printf("Test.str=%s\n", st->str);
free(st);
st = NULL;
return 0;
}
好处
在我们看来柔性数组就是一个指针，那么我们将柔性数组的那个设计成指针
typedef struct Test {
int a;
double c;
char *str;
}Test;
int main() {
char str[] = "Hello World";
Test *test=(Test*)malloc(sizeof(Test));
test->str = (char*)malloc(strlen(str)+1);
strcpy(test->str,str);
printf("str=%s\n",test->str);
free(test->str);//要释放结构体中的指针，如果不释放就会造成内存泄漏
free(test);
return 0;
}
总结：虽然我们实现了同样的功能，但是对于内部结构不了解，就会只释放test,因此造成内存泄漏。
使用柔性数组的好处：
■ 方便内存释放，内存管理
■ 节省内存，柔性数组不占用空间
■ 将数据和结构统一管理起来