第六章 动态内存申请

第六章 动态内存分配

6.1 动态分配内存的概述

在数组一章中，介绍过数组的长度是预先定义好的，在整个程序中固定不变，但是在实际的编程中，往往会发生这种情况

既所需的内存空间取决于实际输入的数据，而无法预先确定。

为了解决上诉问题，C语言提供了一些内存管理函数，这些内存管理函数可以按需要动态地分配内存空间，也可把不再使用的空间回收再次利用。

动态分配内存就是在堆区开辟空间

6.2 静态分配、动态分配

静态分配：

1. 在程序编译或运行过程中，根据需要大小自由分配所需空间int a[10]
2. 必须事先知道所需空间的大小
3. 分配在栈区或全局变量区，一般以数组的形式
4. 按计划分配

动态分配：

1. 在程序运行过程中，根据需要大小自由分配所需空间
2. 按需分配
3. 分配在堆区，一般使用特定的函数进行分配

6.3 动态分配函数

6.3.1 malloc()函数

头文件： #include <stdlib.h>

函数原型： void *malloc(unsigned int size)

功能说明：

在内存的动态存储区（栈区）中分配一块长度为size字节的连续区域
，用来存放类型说明符指定的类型。
函数原型返回void*指针，使用时必须做相应的强制类型转换，分配的内存空间内容不确定，一般使用memset初始化

返回值：

分配空间的起始地址（分配成功）

NULL（分配失败）

注意：

1. 在调用malloc之后，一定要判断一下，是否申请内存成功
2. 如果多次malloc申请的内存，第一次和第二次申请的内存不一定是连续的
3. 使用malloc开辟空间需要保存开辟好的空间的首地址，但是由于不确定空间用于做什么，所以本身返回值类型为void *，所以在调用函数时根据接收者的类型对其进行强制类型转换

案例：

#include <stdio.h>
#include <stdlib.h>


char *fun() {
    // 局部变量 函数结束之后释放内存空间
    // char ch[100] = "hello world";

    // 静态全局区的空间只要开辟好，除非程序结束，否则不会释放
    // 所以如果只是临时使用，不建议使用静态全局区的空间
    // static char ch[100] = "hello world";

    // 堆区开辟空间，手动申请、手动释放，更加灵活
    // 使用malloc函数的时候一般要进行强制转换
    char *str = (char *)malloc(100 * sizeof(char));
    str[0] = 'h';
    str[1] = 'e';
    str[2] = 'l';
    str[3] = 'l';
    str[4] = 'o';
    str[5] = ' ';
    str[6] = 'w';

    return str;
}

int main(int argc, char const *argv[])
{
    /* code */
    char *p;
    p = fun();
    printf("p = %s\n", p);
    return 0;
}

6.3.2 free()函数（释放内存函数）

头文件： #include <stdlib.h>

函数定义：void free(void *ptr)

函数说明： free函数释放ptr指向的内存

返回值： 无

注意：

1. ptr指向的内存必须是malloc\calloc\relloc动态申请的内存,不能只释放一部分
2. free函数只能释放堆区的空间，其它区域的空间无法使用free
3. free(p);，注意当free之后，因为没有给p赋值，所以p还是指向原先动态申请的内存，但是内存已经不能再用了，p就变成了野指针。所以一般为了防止野指针，会free完毕之后对p赋为NULL
4. 一块动态申请的内存只能free一次，不能多次free

6.3.3 calloc()函数

头文件： #include <stdlib.h>

函数原型： void * calloc(size_t nmemb, size_t size)

size_t实际是无符号整型，它是在头文件中，用typedef定义出来的

函数的功能： 在内存的堆中，申请nmemb块，每块的大小为size个字节的连续区域

函数的返回值：

• 返回 申请的内存的首地址（成功）
• 返回 NULL（失败）

注意：

malloc和calloc函数都是用来申请内存的

区别：

1. 函数的名字不一样
2. 函数的参数个数不一样
3. malloc申请的内存，内存中存放的内容是随机的、不确定的，而calloc函数申请的内存中的内容为0

案例：

#include <stdio.h>
#include <stdlib.h>


int main(int argc, char const *argv[])
{
    // 在堆区申请3块空间，每块大小为100个字节，即300个字节连续的区域
    char *p = (char *)calloc(3, 100);
    return 0;
}

6.3.4 realloc()函数（重新申请内存）

咱们调用malloc和calloc函数单次申请的内存是连续的，两次申请的两块内存不一定是连续的。

或者有时候有这种需求，既我先用malloc或者calloc申请了一块内存，我还想在原先内存的基础上挨着申请内存或者我开始使用malloc或者calloc申请了一块内存，我想释放后边的一部分内存，为了解决这个问题，创造了realloc函数。

头文件： `#include <stdlib.h>

函数原型： void* realloc(void *s, unsigned int newsize)

参数：

• s-原本开辟好的空间的首地址
• newsize：重新需要开辟的空间大小

函数的功能：`

在原先s指向的内存基础上重新申请内存，新的内存大小为new_size个字节
如果原先内存后面有足够大的空间就追加，如果后边的内存不够用，则realloc函数
会在堆区重新找一个newsize个字节大小的内存申请，将原先内存中的内容拷贝过来
，然后释放原先的内容，最后返回新内存的地址

如果newsize比原先的内存小，则会释放原先的内存后面的存储空间，只留前面的newsize个字节

返回值： 新申请的内存的首地址

案例：

#include <stdio.h>
#include <stdlib.h>

void test1() {
    char *p;
    p = (char *)malloc(100);

    // 在100个字节后面追加50个字节
    p = (char *)realloc(p, 150); // p指向的内存的新的大小为150字节
}

// 减少空间
void test2() {
    char *p;
    p = (char *)malloc(100);

    // 想重新申请内存，新的大小为50个字节
    p = (char *)realloc(p, 50); // p指向的内存的大小为50个字节，100个字节后50个字节的存储空间就被释放了
}

int main(int argc, char const *argv[])
{
    return 0;
}

注意： malloc/calloc/realloc申请的动态空间，只会在程序结束的释放或者使用free释放

6.4 内存泄漏

内存泄漏的概念：

申请的内存，首地址丢了，找不到了，再也没法使用了，但是申请的动态存储空间没有释放，这块内存也就泄露了

内存泄漏案例1

#include <stdio.h>
#include <stdlib.h>
int main()
{
    char *p;
    p = (char *)malloc(100);
    // 接下来，可以用p指向的内存了

    p = "hello world"; // p指向别的地方了,保存字符串常量的首地址
    // 从此以后，再也找不到你申请的100个字节了，则动态申请的100个字节就被泄露了
    return 0;
}

内存泄漏案例2：

#include <stdio.h>
#include <stdlib.h>

void fun()
{
    char *p;
    p = (char *)malloc(100);
    // p没有释放，并且没有返回
}
int main()
{
    // 接下来没调用一次fun就泄漏100字节
    fun();
    fun();

    return 0;
}

内存泄漏解决方案1

#include <stdio.h>
#include <stdlib.h>
int main()
{
    char *p;
    p = (char *)malloc(100);
    // 接下来，可以用p指向的内存了


    // 记住释放p
    free(p);
    return 0;
}

内存泄漏解决方案2

#include <stdio.h>
#include <stdlib.h>

void fun()
{
    char *p;
    p = (char *)malloc(100);
    // 接下来，可以用p指向的内存了
    ;
    ;
    return p;
}
int main()
{
    // 接下来没调用一次fun就泄漏100字节
    char *q;
    q = fun();

    // 记得释放
    free(p);
    return 0;
}

总结：
申请的内存，一定不要把首地址给丢了，在不用的时候一定要释放内存