[C++知识库]关于动态内存管理，你需要知道什么？——C语言

目录

一、为什么存在动态内存分配

二. 动态内存函数的介绍

2.1 malloc 和 free

2.2?calloc

2.3 realloc

三、常见的动态内存管理错误

3.1对空指针进行解引用操作

3.2在开辟的动态空间进行越界访问

3.3 对非开辟的动态内存空间进行释放

3.4?使用free释放一块动态开辟内存的一部分

3.5 对同一块动态内存多次释放

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

一、为什么存在动态内存分配

在我们还没有学习到动态内存分配之前，通常都是这样开辟空间的：

char str;//在栈上开辟一个字节的空间
int arr[50];//在栈上开辟200个字节的连续空间

这样开辟空间的方式有两个特点：

1、开辟的空间大小是固定的

2、数组在声明时必须标出数组长度，而数组所需要的内存在编译时分配。

而有时通过程序运行，我们才知道我们需要的空间大小，这时很可能会出现我们对于空间需求的预计和实际情况不符合的情况。那数组的编译时开辟空间的方式就不能满足了，这就需要用到我们的动态内存分配的方法解决问题。

二. 动态内存函数的介绍

C语言提供了一些动态内存开辟的函数，在这我们介绍几个常用的动态内存开辟函数。

2.1 malloc 和 free

malloc函数分配所需的内存空间，并返回一个指向它的指针，malloc的声明如下：

void *malloc(size_t size);

参数：size?-- 指内存块的大小，以字节为单位。

返回值：若malloc请求成功，则返回一个指向已分配内存空间的指针 ，如果请求失败，则返回 NULL。（所以使用malloc时，我们先需要判断它是否请求成功，避免野指针问题。）并且返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。

free函数释放之前调用 calloc、malloc 或 realloc 所分配的内存空间。它的声明如下：

void free(void *ptr);

参数：ptr -- 指针指向一个要释放内存的内存块，该内存块之前是通过调用 malloc、calloc 或 realloc 进行分配内存的。如果传递的参数是一个空指针，则不会执行任何动作。

返回值：该函数不会返回任何值。

注：当动态内存空间使用完毕后需及时用free函数释放动态内存空间，否则会出现内存泄漏的问题。

正确的free函数使用案例：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int main()
{
   char *str;
 
   /* 开始内存分配 */
   str = (char *) malloc(15);
   strcpy(str, "abcdef");
   printf("String = %s,  Address = %p\n", str, str);
 
 
   /* 释放已分配的内存 */
   free(str);
   str = NULL;
 
   return 0;
}

2.2?calloc

calloc函数分配所需的内存空间，并返回一个指向它的指针。malloc?和?calloc?之间的不同点是，malloc 不会将分配的内存初始化为0，而 calloc 会将分配的内存初始化为零。

void *calloc(size_t nitems, size_t size);//calloc函数声明

参数：?nitems?-- 要被分配的元素个数。size?-- 元素的大小。

返回值：若calloc请求成功则会返回指向新开辟内存空间的指针，否则返回NULL。

calloc正确使用方法：

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

int main()
{
    int i, n;
    int* ptr;
   
    printf("要输入的元素个数：");
    scanf("%d", &n);

    int* a;
    a = (int*)calloc(n, sizeof(int));

    if (NULL != a)
    {
        ptr = a;
        printf("输入 %d 个数字：\n", n);
        for (i = 0; i < n; i++)
        {
            scanf("%d", &(*(ptr + i)));
        }

        printf("输入的数字为：");
        for (i = 0; i < n; i++)
        {
            printf("%d ", ptr[i]);
        }

        free(a);  // 释放内存
        a = NULL;
    }
    else
    {
        perror(a);//calloc请求失败时报错
    }
    return 0;
}

2.3 realloc

realloc函数尝试重新调整之前调用?malloc?或?calloc?所分配的?ptr?所指向的内存块的大小。

它的声明如下：

void *calloc(size_t nitems, size_t size);

参数：

• ptr?-- 指针指向一个要重新分配内存的内存块，该内存块之前是通过调用 malloc、calloc 或 realloc 进行分配内存的。如果为空指针，则会分配一个新的内存块，且函数返回一个指向它的指针。
• size?-- 内存块的新的大小，以字节为单位。如果大小为 0，且 ptr 指向一个已存在的内存块，则 ptr 所指向的内存块会被释放，并返回一个空指针。

返回值：该函数返回一个指向已分配的内存的指针。如果请求失败，则返回 NULL。

realloc正确使用方式：

#include <stdio.h>
#include <stdlib.h>
int main()
{
 int *ptr = (int*)malloc(100);
 if(ptr != NULL)
 {
     //业务处理
 }
 else
 {
     exit(EXIT_FAILURE);    
 }

 //扩展容量

 int*p = NULL;
 p = realloc(ptr, 1000);

 if(p != NULL)
 {
     ptr = p;
 }
 //业务处理
 free(ptr);
 return 0;
}

三、常见的动态内存管理错误

3.1对空指针进行解引用操作

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

3.2在开辟的动态空间进行越界访问

//以下为错误示范
void test()
{
     int i = 0;
     int *p = (int *)malloc(5*sizeof(int));

 if(NULL == p)
 {
     exit(EXIT_FAILURE);
 }

 for(i=0; i<=5; i++)
 {
     *(p+i) = i;//当i是5的时候越界访问
 }

     free(p);
     p = NULL;

     return 0;
}

3.3 对非开辟的动态内存空间进行释放

void test()
{
     int a = 10;
     int *p = &a;

     free(p);//ok?
     p = NULL;
}

3.4?使用free释放一块动态开辟内存的一部分

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

    free(p);//p不再指向动态内存的起始位置
    p = NULL;
    return 0;
}

3.5 对同一块动态内存多次释放

void test()
{
 int *p = (int *)malloc(100);
 free(p);
 free(p);//重复释放
}

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

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

int main()
{
    int i, n;
    int* ptr;
   
    printf("要输入的元素个数：");
    scanf("%d", &n);

    int* a;
    a = (int*)calloc(n, sizeof(int));

    if (NULL != a)
    {
        //工作内容
        //...
    }

    return 0;
}