C语言——动态内存分配

free函数用来释放动态开辟的内存！！！

头文件也是stdlib.h

#include<stdio.h>
#include<stdlib.h>int main()
{int num = 0;scanf("%d", &num);//开辟num个int大小的内存空间int* parr = (int*)malloc(num * sizeof(int));//malloc返回类型为void*，这里可以进行强制类型转换//转换成我们需要的类型//需要判断内存空间是否开辟成功if (parr == NULL){perror("malloc");return 1;}//开辟成功else{//给开辟的空间赋值int i = 0;for (i = 0; i < num; i++){*(parr + i) = i;printf("%d ", *(parr + i));}printf("\n");}free(parr);//释放动态内存开辟的空间parr = NULL;//后面会讲解，事实上是避免野指针的发生return 0;
}

#include<stdio.h>
#include<stdlib.h>int main()
{int num = 0;scanf("%d", &num);//开辟num个int大小的内存空间int* parr = (int*)calloc(num, sizeof(int));//calloc返回类型为void*，这里可以进行强制类型转换//转换成我们需要的类型//需要判断内存空间是否开辟成功if (parr == NULL){perror("calloc");return 1;}//开辟成功else{//calloc开辟的空间每个字节初始化全部为0int i = 0;for (i = 0; i < num; i++){*(parr + i) = i;printf("%d ", *(parr + i));}printf("\n");}free(parr);//释放动态内存开辟的空间parr = NULL;//避免野指针return 0;
}

#include<stdio.h>
#include<stdlib.h>int main()
{int num = 0;scanf("%d", &num);//开辟num个int大小的内存空间int* parr1 = (int*)malloc(num * sizeof(int));int* parr2 = (int*)calloc(num, sizeof(int));//calloc返回类型为void*，这里可以进行强制类型转换//转换成我们需要的类型//需要判断内存空间是否开辟成功if (parr1 == NULL){perror("malloc");return 1;}if (parr2 == NULL){perror("calloc");return 1;}//开辟成功else{//calloc开辟的空间每个字节初始化全部为0//malloc开辟空间初值为随机值int i = 0;printf("malloc:\n");for (i = 0; i < num; i++){printf("%d ", *(parr1 + i));}printf("\n");printf("calloc:\n");for (i = 0; i < num; i++){printf("%d ", *(parr2 + i));}printf("\n");}free(parr1);//释放动态内存开辟的空间free(parr2);parr1 = parr2 = NULL;//避免野指针return 0;
}

calloc开辟的空间每个字节初始化全部为0，而malloc开辟空间初值为随机值 。

所以如果我们 对申请的内存空间的内容要求初始化 ，那么可以很方便的使用 calloc函数 来完成任务。

realloc

realloc 函数就可以调整动态开辟内存大小

头文件：stdlib.h

解释：

• ptr 是要调整的内存地址

• size 调整之后新的大小

• 返回值为调整之后的内存起始位置

• 这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间

• realloc在调整内存空间的是存在两种情况：

         情况1：原有空间之后有足够大的空间

         情况2：原有空间之后没有足够大的空间

情况1 ：原有空间之后有足够大的空间

当是情况1的时候，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化，返回的地址就是原来内存地址的起始位置。

情况2 ：原有空间之后没有足够大的空间

当是情况2 的时候，原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找⼀个合适大小 的连续空间来使用，这样函数返回的是⼀个新的内存地址。

由于上述的两种情况，realloc函数的使用也就要注意⼀些！

//代码1 - 直接将realloc的返回值放到parr中
parr = (int*)realloc(parr, 20 * sizeof(int));

如果我们这样将realloc的返回值放到parr中，编译器就会报出警告，这是因为parr可能没有新开辟空间成功，就会返回NULL，再给parr，那么就会导致原来的数据缺失， 造成内存泄漏。

正确写法：

//代码2 - 先将realloc函数的返回值放在temp中，不为NULL，在放parr中
int* temp = (int*)realloc(parr, 20 * sizeof(int));
if (temp != NULL)
{parr = temp;
}

简单使用：

#include<stdio.h>
#include<stdlib.h>
int main()
{int* parr = (int*)malloc(10 * sizeof(int));if (parr == NULL){perror("malloc");return 1;}else{int i = 0;for (i = 0; i < 10; i++){*(parr + i) = i;printf("%d ", *(parr + i));}printf("\n");}///代码1 - 直接将realloc的返回值放到parr中//错误写法//parr = (int*)realloc(parr, 20 * sizeof(int));//代码2 - 先将realloc函数的返回值放在temp中，不为NULL，在放parr中int* temp = (int*)realloc(parr, 20 * sizeof(int));if (temp != NULL){parr = temp;}int i = 0;for (i = 0; i < 20; i++){*(parr + i) = i;printf("%d ", *(parr + i));}printf("\n");free(parr);parr = NULL;return 0;
}

常见的动态内存的错误

对NULL指针的解引用操作

void test()
{int* p = (int*)malloc(sizeof(int));*p = 20;//如果p的值是NULL，就会有问题free(p);
}

所以在使用的时候我们首先要判断空间是否开辟成功，不可以对NULL指针进行解引用操作。

正确代码：

void test()
{int* p = (int*)malloc(sizeof(int));if (p == NULL){perror("malloc");//显示错误exit(1);//退出程序}*p = 20;//如果p的值是NULL，就会有问题free(p);p = NULL;
}

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

//越界访问
void test()
{int i = 0;int* p = (int*)malloc(10 * sizeof(int));//开辟10个整型大小的空间if (NULL == p){perror("malloc");exit(1);}for (i = 0; i <= 10; i++){*(p + i) = i;//当i是10的时候越界访问}free(p);p = NULL;
}

代码退出为3，只开辟了10个整型大小的空间，数组下标从0开始，当下标是10，很明显是越界访问，所以使用的时候要特别注意开辟内存空间的大小。

对非动态开辟内存使用free释放

//对非动态开辟内存使用free释放
void test()
{int* p = NULL;int a = 10;p = &a;free(p);//p不是动态内存开辟的
}

我们可以看到对不是动态内存开辟的空间是不可以使用free进行释放的。

使用free释放⼀块动态开辟内存的⼀部分

//使用free释放⼀块动态开辟内存的⼀部分
void test()
{int* p = (int*)malloc(10 * sizeof(int));p++;free(p);//p不再指向动态内存的起始位置
}

这一种行为也是不被允许的，free应该释放掉动态内存开辟的所有部分，我们使用的时候需要特别注意。

对同⼀块动态内存多次释放

//对同一块动态内存开辟的空间进行重复释放
void test()
{int* p = (int*)malloc(10 * sizeof(int));free(p);free(p);//重复释放
}

动态开辟内存忘记释放（内存泄漏）

// 动态开辟内存忘记释放（内存泄漏）void test()
{int* p = (int*)malloc(sizeof(int));if (NULL != p){*p = 20;}//调用了test函数进行了动态内存开辟//但是没有进行释放
}

动态开辟的空间⼀定要释放，并且正确释放！！！

malloc和free成对使用！！！

动态内存相关题目分析

题目一

void GetMemory(char* p)
{p = (char*)malloc(100);
}
void test(void)
{char* str = NULL;GetMemory(str);strcpy(str, "hello world");printf(str);
}

我们可以看到这一段代码是有问题的，程序崩溃了，并且没有输出内容。这是为什么呢？

我们一起来分析分析，首先指针变量str最开始给的是NULL，希望通过GetMemory函数获得一块内存空间，在GetMemory函数中，动态申请空间给p，事实上，str和p指向的不是同一块内存空间，想把"hello world"复制到str中，str在函数调用以后依然是NULL，所以不能对空指针进行解引用，发生错误，除此之外，这里的代码还没有对动态申请的空间进行释放，这也是存在问题的，会导致内存泄漏的问题。

总结：

1.对空指针进行解引用

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 = (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;
}

两种修改方式都可以达到我们想要的效果。

题目二

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

这一段代码也没有达到我们想要的效果，打印的是乱码，说明是存在问题的。

我们一起来分析分析：这里面进入GetMemory函数，函数里面创建了一个字符数据，这里p就是函数内部的局部变量，存放在内存的栈区，当函数调用结束，这一块地址相应的内容就会被销毁，还给操作系统，操作系统存放其他数据，是随机的，也就出现了乱码。

题目三

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

这一段代码乍一看，看起来没有什么问题，传str地址，调用GetMemory函数，开辟100字节大小的空间，事实上，这一段代码存在的问题就是没有对动态开辟的内存进行释放，存在内存泄漏的问题。

正确代码：

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

题目四

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

这一段代码又有什么问题呢？

这一段代码的主要问题是str没有及时置为空，str成为野指针，指向一块内存空间，后面再次使用strcpy就造成了非法访问，所以使用free释放动态内存开辟的空间时，要将相应的指针及时置为空，同时更好的修改代码，在malloc之后要判断是否创建空间成功。

修改：

//修改void test(void)
{char* str = (char*)malloc(100);if (str == NULL){perror("malloc");exit(1);//创建失败退出程序}strcpy(str, "hello");printf(str);//printf("world");free(str);//str及时置为空，避免str成为野指针str = NULL;if (str != NULL){strcpy(str, "world");printf(str);}
}
int main()
{test();return 0;
}

柔性数组

定义

C99 中，结构中的最后⼀个元素允许是未知大小的数组，叫做『柔性数组』成员

//柔性数组
struct st_type
{int i;int a[0];//柔性数组成员
};
//一些编译器可能报错，可以改成：struct st_type
{int i;int a[];//柔性数组成员
};

特点

• 结构中的柔性数组成员前面必须至少⼀个其他成员。

• sizeof 返回的这种结构大小不包括柔性数组的内存。

• 包含柔性数组成员的结构⽤malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小 以适应柔性数组的预期大小。

typedef struct st_type
{int i;int a[0];//柔性数组成员
}type_a;
int main()
{printf("%zd\n", sizeof(type_a));//输出的是4return 0;
}

使用

typedef struct st_type
{int i;int a[0];//柔性数组成员
}type_a;
//代码1：
int main()
{int i = 0;type_a* p = (type_a*)malloc(sizeof(type_a) + 100 * sizeof(int));if (p == NULL){perror("malloc");exit(1);}//业务处理p->i = 100;for (i = 0; i < 100; i++){p->a[i] = i;printf("%5d ", p->a[i]);}free(p);return 0;
}

柔性数组成员a相当于获得100个整型元素的连续空间

优势

实现上面的功能，我们也可以使用下面的代码：

//代码2
typedef struct st_type
{int i;int* p_a;
}type_a;
int main()
{type_a* p = (type_a*)malloc(sizeof(type_a));if (p == NULL){perror("malloc");exit(1);}p->i = 100;p->p_a = (int*)malloc(p->i * sizeof(int));if (p->p_a == NULL){perror("malloc");exit(1);}//业务处理for (int i = 0; i < 100; i++){p->p_a[i] = i;printf("%5d", p->p_a[i]);}//释放空间free(p->p_a);p->p_a = NULL;free(p);p = NULL;return 0;
}

它们可以达到同样的效果，那么使用第一段代码有什么优势呢？

第⼀个好处是：方便内存释放

如果我们的代码是在⼀个给别⼈用的函数中，你在里面做了⼆次内存分配，并把整个结构体返回给用户 。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能 指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存⼀次性分配好了，并返 回给用户⼀个结构体指针，用户做⼀次free就可以把所有的内存给释放掉。

第二个好处是：有利于提高访问速度.

连续的内存有益于提高访问速度，也有益于减少内存碎片。