动态内存管理

动态内存管理

• 1.为什么要有动态内存分配
• 2.malloc和free
• 3.calloc和realloc
• 4.常见的动态内存的错误
• 5.动态内存经典笔试题分析
• 6.柔性数组
• 7.总结C/C++中程序内存区域划分
• • 1.为什么要有动态内存分配
  • 2.malloc和free
  • • 2.1malloc
    • 2.2free
  • 3.calloc和realloc
  • • 3.1calloc
    • 3.2realloc
  • 4.常见的动态内存的错误
  • • 4.1对NULL指针的解引用操作
    • 4.2对动态开辟空间的越界访问
    • 4.3对非动态开辟内存使用free释放
    • 4.4使用free释放一块动态开辟的内存
    • 4.5对一块动态内存多次释放
    • 4.6动态开辟内存忘记释放（内存泄漏）
  • 5.动态内存经典笔试题分析
  • • 5.1题目1
    • 5.2题目2
    • 5.3题目3
    • 5.4题目4
  • 6.柔性数组
  • • 6.1柔性数组的特点
    • 6.2柔性数组的应用
    • 6.3柔性数组的优势
  • 7.总结C/C++中程序内存区域划分

1.为什么要有动态内存分配

2.malloc和free

3.calloc和realloc

4.常见的动态内存的错误

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

6.柔性数组

7.总结C/C++中程序内存区域划分

1.为什么要有动态内存分配

int s = 4，这种空间开辟大小是固定的。

2.malloc和free

2.1malloc

C语言为我们提供了一个内存开辟函数：

void* malloc(size_t size);

这个函数向内存申请一块连续可用的空间，并且返回指向这块空间的指针。

• 若开辟成功，返回一个指向开辟空间的指针。
• 若开辟失败，返回一个NULL指针，因此malloc的返回值一定要做检查。
• 返回值是void*,所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自身来决定。
• 若参数size为0，malloc的行为是标准未定义的，取决于编译器。

2.2free

C语言提供了另一个函数free，专门用来做动态内存的释放和回收的：

void free(void* ptr);

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

• 若参数ptr指向的空间不是动态开辟的，那free函数的行为是未定义的。
• 若参数ptr是NULL指针，则函数什么都不做。 malloc和free都声明在stdlib.h头文件中。

#include <stdlib.h>
//20个字节 – 存放5个整数
int main()
{
//自己在开辟内存空间时已经知道要存什么数据了，因此这时要明确
int* p = (int*)malloc(20);
if (p == NULL)
{
perror("malloc");
return 1;
}
//使用空间
int i = 0;
for (i = 0; i < 5; i++)
{
*(p + i) = i + 1;
}
//释放内存
free(p);//传递给free函数的地址是要释放的内存空间的起始地址
//释放内存后，已经没有访问权限，但此时p的值不变，因此p会变为野指针，要进行处理
p = NULL;
return 0;
}

3.calloc和realloc

3.1calloc

C语言还提供了一个函数叫calloc,calloc函数也用来动态内存分配。

void* calloc(size_t num,size_t size);

• 函数的功能是为num个size字节大小的元素开辟一块空间，并且把空间每一个字节初始化为0，这是和malloc函数的区别。

所以如果对申请内存空间的内容要求初始化，那么可以使用calloc函数完成。

3.2realloc

• realloc函数的出现让动态内存管理更加灵活。
• realloc函数可以做到对动态开辟内存大小调整。

void* realloc(void* ptr,size_t size)

• ptr是要调整的内存地址
• size是调整之后的大小
• 返回值为调整之后的内存起始位置
• 这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移到新的空间
• realloc函数在调整内存空间时存在两种情况： 情况1：原有空间之后有足够大的空间 情况2：原有空间之后没有足够大的空间 情况1 在原有内存之后直接追加空间，原来数据不发生变化。 情况2 在堆空间上另找一个合适大小的连续空间来使用。这样函数返回的是一个新的内存地址。 具体步骤： 1.在堆区的内存中找一个新的空间，并且符合新大小要求 2.把原来的空间的数据拷贝一份到新的空间 3.释放旧的空间 4.返回新的内存空间的起始地址 realloc函数使用注意一些。

#include <stdio.h>
#include <stdlib.h>
int main()
{
int* ptr = (int*)malloc(100);
if (ptr != NULL)
{
//业务处理
}
else
{
return 1;
}
//扩展容量
//代码1 – 直接将realloc的返回值放到ptr中
ptr = (int*)realloc(ptr, 1000);//这样是不行的，如果申请失败，返回一个NULL指针给ptr，那么原空间也找不到了
//代码2 – 先将realloc函数的返回值放在p中，不为NULL，再放ptr中
int* p = NULL;
p = (int*)realloc(ptr, 1000);
if (p != NULL)
{
ptr = p;
}
//业务处理
free(ptr);
return 0;
}

4.常见的动态内存的错误

4.1对NULL指针的解引用操作

void test()
{
int* p = (int*)malloc(INT_MAX);
//INT_MAX过大开辟失败，会返回NULL指针
*p = 20;//不能对NULL指针解引用
free(p);
p = NULL;
}

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

void test()
{
int i = 0;
int* p = (int*)malloc(10 * sizeof(int));
if (p == NULL)
{
exit(EXIT_FAILURE);
}
for (i = 0; i <= 10, i++)
{
*(p + i) = i;
}
free(p);
p = NULL;
}

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

void test()
{
int a = 10;
int* p = &a;
free(p);//是不行的
p = NULL;
}

4.4使用free释放一块动态开辟的内存

void test()
{
int* p = (int*)malloc(100);
p++;
free(p);
p = NULL;
}

4.5对一块动态内存多次释放

void test()
{
int* p = (int*)malloc(100);
free(p);
free(p);
}

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

void test1()
{
int* p = (int*)malloc(100);
if (p != NULL)
{
*p = 20;
}
}
int main()
{
test1();//出函数时变量p销毁，且内存未释放，也找不到了
while (1);
//陷入死循环
return 0;
}

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

5.1题目1

//Test运行结果？
void GetMemory(char* p)
{
p = (char*)malloc(100);
}
void Test(void)
{
char* str = NULL;
GetMemory(str);//属于传值，str值没有改变，出函数后p变量销毁造成内存泄漏
strcpy(str, "hello world");//str为NULL指针，不能解引用，会出现错误
printf(str);
}
//调整代码后
//1.用传址方式传参
void GetMemory(char** p)
{
*p = (char*)malloc(100);
}
void Test(void)
{
char* str = NULL;
GetMemory(&str);//传址传递
strcpy(str, "hello world");
printf(str);
}
//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;
}

5.2题目2

//Test运行结果？
char* GetMemory(void)
{
char p[] = "hello world";
return p;
}
void Test(void)
{
char* str = NULL;
str = GetMemory();
//GetMemory函数返回后，使用str指针去访问p数组就是非法访问，因为p数组的内存已经还给了操作系统。此时str是野指针
printf(str);

5.3题目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申请的内存
//完善后：
free(str);
str = NULL;
}

5.4题目4

void Test(void)
{
char* str = (char*)malloc(100);
strcpy(str, "hello");
free(str);
//此段代码考查free(str)后，str为野指针，我们需要完善
//完善：
str = NULL;
if (str != NULL)
{
strcpy(str, "world");
printf(str);
}
}

6.柔性数组

C99中，结构体中最后一个元素是未知大小的数组，这就叫做柔性数组成员。 例如：编译器报错就是另一种形式

//两种形式
struct Cp
{
int i;
int a[0];
};
struct Cp
{
int i;
int a[];
};

6.1柔性数组的特点

• 结构体中的柔性数组成员前面必须至少有一个其他成员。
• sizeof返回的这种结构体大小不包括柔性数组的内存。
• 包含柔性数组成员的结构体用malloc()函数进行内存分配，并且分配的内存应该大于结构体的大小，以适应柔性数组的预期大小。

6.2柔性数组的应用

代码1：

#include <stdio.h>
#include <stdlib.h>
int main()
{
struct S* ps = (struct S*)malloc(sizeof(struct S) + 5 * sizeof(int));
if (ps == NULL)
{
perror("malloc");
return 1;
}
ps->n = 100;
int i = 0;
for (i = 0; i < 5; i++)
{
ps->a[i] = i;
}
//调整空间
struct S* ptr = (struct S*)realloc(ps, 10 * sizeof(int));
if (ptr != NULL)
{
ps = ptr;
}
//使用…

//释放：
free(ps);
ps = NULL;
return 0;
}

6.3柔性数组的优势

上述struct S结构体用以下代码也可以实现： 代码2：

#include <stdio.h>
#include <stdlib.h>
struct S
{
int n;
int* arr;
};
int main()
{
struct S* ps = (struct S*)malloc(sizeof(struct S));
if (ps == NULL)
{
perror("malloc");
return 1;
}
//要使内存都由malloc来申请，用来和代码1作比较
ps->arr = (int*)malloc(5 * sizeof(int));
if (ps->arr == NULL)
{
return 1;
}
//使用:
ps->n = 100;
int i = 0;
for (i = 0; i < 5; i++)
{
ps->arr[i] = i;
}
//调整数组大小：
int* ptr = (int*)malloc(10 * sizeof(int));
if (ptr != NULL)
{
ps->arr = ptr;
}
//使用…

//释放：
free(ps->arr);
ps->arr = NULL;
free(ps);
ps = NULL;
return 0;
}

好处1：方便内存释放 好处2：有利于访问速度

7.总结C/C++中程序内存区域划分