C语言深入学习 --- 5.动态内存管理

  • 开发
  • 38

文章目录

第五章 动态内存管理

1.存在动态内存分配的意义

2.动态内存函数

  • malloc

  • free

  • calloc

  • realloc

3.常见的动态内存错误

4.经典笔试题

5.C/C++程序的内存开辟

6.柔性数组

1.存在动态内存分配的意义

    int x = 5; //在栈空间中开辟了大小为4个字节的空间
    char arr[5] = { 0 }; //在栈空间上开辟了5个连续的字节空间。

以上开辟空间的方式有两个特点：

1.空间开辟的大小是固定的。

2.数组在声明的时候，必须要指定数组的长度，编译时分配所需要的内存空间。
有时候需要的空间大小在程序运行后才知道，以上的开辟空间方式就不能满足了。

2.动态内存函数

2.1 malloc和free

动态内存开辟函数：

void* malloc (size_t size);

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

开辟成功，则返回一个指向开辟好的空间的指针。

开辟失败，则返回一个NULL指针。

返回值类型为void*，malloc函数不知道要开辟什么类型的空间，在使用的时候要自己决定。

size为0时，malloc的行为是标准是未定义的，取决编译器。

动态内存的释放和回收函数：

void free (void* ptr)

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

参数ptr所指向的空间不是动态开辟的，那么free函数的行为是未定义的。

参数ptr是NULL指针的话，则函数什么都不做。

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

int main()
{
    //1
    int num = 0;
    scanf("%d", &num);
    int arr[num] = { 0 };
    //2
    int* ptr = NULL;
    ptr = (int*)malloc(num * sizeof(int));
    if (ptr != NULL)
    {
        int i = 0;
        for (i = 0; i < num; i++)
        {
            *(ptr + i) = 0;
        }
    }
    free(ptr);
    ptr = NULL;
    return 0;
}
2.2 calloc

calloc也可以用来进行动态内存分配。

void* calloc (size_t num, size_t size);

num个大小为size的元素开辟一块空间，并把空间每个字节都初始化为0。

与malloc不同的是calloc会在返回地址之前把申请的空间都初始化为0。

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

int main()
{
    int* p = (int*)calloc(5, sizeof(int));
    if (p != NULL)
    {
        //使用空间
    }
    free(p);
    p = NULL;
    return 0;
}

如果对申请的空间需要初始化，可以使用calloc函数来完成。

2.3 realloc

realloc函数让动态内存管理更加灵活。

有时申请的空间太小了又或者太大了，为了合理的分配内存，需要对内存的大小做灵活的调整。realloc函数就可以对动态开辟内存大小进行调整。

void* realloc (void* ptr, size_t size);

  • ptr为需要调整的内存地址。

  • size为调整之后的新大小。

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

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

  • realloc在调整空间时存在两种情况：

1.原有空间之后有足够大的空间，要扩展内存就直接在原在内存之后追加空间，原先空间的数据不会发生变化。

2.原有空间之后没有足够大的空间时，扩展内存就会在堆空间上另外找一个大小合适的连续空间使用。函数返回的是新的内存地址。

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

int main()
{
    //1
    int* ptr = (int*)malloc(100);
    if (ptr != NULL)
    {

    }
    else
    {
        perror(main);
    }
    ptr = realloc(ptr, 1000);


    //2
    int* p = NULL;
    p = (int* )realloc(ptr,1000);
    if (p != NULL)
    {
        ptr = p;
    }
    else
    {
        perror(main);
    }
    free(ptr);
    ptr = NULL;
    return 0;
}

3.常见的动态内存错误

3.1 对NULL指针的解引用操作
int main()
{
    int* p = (int*)malloc(INT_MAX/ 2);
    *p = 10; //如果p的值为NULL,会出现问题。
    free(p);
    p = NULL;
    return 0;
}
3.2 对动态开辟空间的越界访问
int main()
{
    int i = 0;
    int* p = (int*)malloc(10 * sizeof(int));
    if (p == NULL)
    {
        return;
    }
    for (i = 0; i <= 10; i++)
    {
        *(p + i) = i; //到i=10时，会出现越界访问的问题。
    }
    free(p);
    p = NULL;
    return 0;
}
3.3 对非动态开辟内存使用free释放
int main()
{
    int a = 10;
    int* p = &a;
    free(p);  //这种做法是错误的，
    return 0;
}
3.4 使用free释放一块内存开辟内存的一部分
int main()
{
    int* p = (int*)malloc(10);
    p++;
    free(p); //此时p不再指向初始地址.
    return 0 ;
}
3.5 对同一块动态内存多次释放
int main()
{
    int* p = (int*)malloc(10);
    free(p);
    free(p); //重复释放
    return 0;
}
3.6 动态开辟内存忘记释放(内存泄漏)
void test()
{
    int* p = (int*)malloc(100);
    if (p != NULL)
    {
        *p = 10;
    }
}

int main()
{
    test();
    return 0;
}

忘记释放不再使用的动态开辟的空间会造成内存泄漏。

动态开辟的空间一定要释放，且正确释放。

4.经典题

4.1 题1：
void GetMemory(char *p)
{
 p = (char *)malloc(100);
}

void Test(void)
{
 char *str = NULL;
 GetMemory(str);
 strcpy(str, "hello world");
 printf(str);
}

int main()
{
    Test();
    return 0;
}

结果：崩溃

4.2 题2：
char *GetMemory(void)
{
 char p[] = "hello world";
 return p;
}

void Test(void)
{
 char *str = NULL;
 str = GetMemory();
 printf(str);
}

int main()
{
    Test();
    return 0;
}

结果：随机值

4.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);
}


int main()
{
    Test();
    return 0;
}

结果：hello

4.4 题4：
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;
}

结果：world

5.C/C++程序的内存开辟

C/C++程序内存分配的几个区域：

  1. 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。

  2. 堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分配方式类似于链表。

  3. 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。

  4. 代码段：存放函数体（类成员函数和全局函数）的二进制代码。

实际上普通的局部变量是在栈区分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁。但是被static修饰的变量存放在数据段（静态区），数据段的特点是在上面创建的变量，直到程序结束才销毁。

所以生命周期变长。

6.柔性数组

在C99中，结构中最后一个元素允许是未知大小的数组，这就叫做【柔性数组】成员。

struct S
{
    int a;
    int arr[0];  //柔性数组成员
};

部分编译器会报错可改成：

struct S
{
    int a;
    int arr[];  //柔性数组成员
};
6.1 柔性数组的特点

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

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

  • 包含柔性数组的结构需要使用malloc函数进行内存的动态分配，且分配的内存该大于结构的大小，以适应柔性数组的预期大小。

typedef struct s_ct
{
    int a;
    int arr[0];
}ct_a;

int main()
{
    printf("%d\n", sizeof(ct_a));  //通过以上的描述，可以知道这里输出的是4.
    return 0;
}
6.2 柔性数组的使用
typedef struct s_ct
{
    int a;
    int arr[0];
}ct_a;

int main()
{
    ct_a* p = (ct_a*)malloc(sizeof(ct_a) + 10*sizeof(int));
    p->a = 10;
    int i = 0;
    for (i = 0; i < 10; i++)
    {
        p->arr[i] = i;
    }
    free(p);
    p = NULL;
    return 0;
}

这里的柔性数组a，相当获得了10个整型元素的连续空间。

6.3 柔性数组的优势

6.2中的代码还可以这样写：

typedef struct s_ct
{
    int a;
    int *pa;
}ct_a;

int main()
{
    ct_a* p = (ct_a*)malloc(sizeof(ct_a));
    p->a = 10;
    p->pa = (ct_a*)malloc(p->a * sizeof(int));
    int i = 0;
    for (i = 0; i < 10; i++)
    {
        p->pa[i] = i;
    }
    free(p->pa);
    p->pa = NULL;
    free(p);
    p = NULL;
    return 0;
}

6.2和6.3的代码可以实现相同的功能，但6.2的方法更好。

原因：

1.方便内存释放

如果把结构体的内存及成员的内存一次性分配好，并返回一个结构体指针，那么只需要做一次free就可以把内存释放掉。是给别人使用的函数中，在里面做二次分配，他人可以通过free释放，但不知道该结构体内的成员也需要free释放。

2.有利于访问速度

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

练习：

1.模拟实现atoi

#include <stdio.h>
#include <limits.h>
#include <ctype.h>

enum State
{
    INVALID,
    VALID
};

enum State state = INVALID;

int my_atoi(const char* p)
{
    int flag = 1;
    if (p == NULL)
    {
        return 0;
    }
    if (*p == '\0')
    {
        return 0;
    }
    while (isspace(*p))
    {
        p++;
    }
    if (*p == '+')
    {
        flag = 1;
        p++;
    }
    else if (*p == '-')
    {
        flag = -1;
        p++;
    }

    long long n = 0;
    while (isdigit(*p))
    {
        n = n * 10 + flag * (*p - '0');
        if (n < INT_MIN || n>INT_MAX)
        {
            return 0;
        }
        p++;
    }
    if (*p == '\0')
    {
        state = VALID;
        return (int)n;
    }
    else
    {
        return (int)n;
    }
}

int main()
{
    const char* p = "   -14a";
    int ret = my_atoi(p);
    if(state == VALID)
        printf("合法：%d\n", ret);
    else
        printf("非法：%d\n", ret);
    return 0;
}

2.一个数组中只有两个数组出现了一次，其他所有数字都出现两次。编写一个函数找出这两个只出现一次的数字。

#include <stdio.h>

void Find(int arr[], int sz, int* x1, int* y1)
{
    int i = 0;
    int ret = 0;
    for (i = 0; i < sz; i++)
    {
        ret ^= arr[i];
    }
    int Pos = 0;
    for (i = 0; i < 32; i++)
    {
        if (((ret >> i) & 1) == 1)
        {
            Pos = i;
            break;
        }
    }

    int num1 = 0;
    int num2 = 0;
    for (i = 0; i < sz; i++)
    {
        if (((arr[i] >> Pos) & 1) == 1)
        {
            num1 ^= arr[i];
        }
        else
        {
            num2 ^= arr[i];
        }
    }
    *x1 = num1;
    *y1 = num2;
}

int main()
{
    int arr[] = { 1,2,3,4,5,6,1,2,3,4 };
    int x = 0;
    int y = 0;
    int sz = sizeof(arr) / sizeof(arr[0]);
    Find(arr, sz, &x, &y);

    printf("%d %d",x, y);
    return 0;
}

上一章：C语言深入学习 — 4.自定义类型(结构体+枚举+联合)

配套练习：

C语言练习题110例(一)
C语言练习题110例(二）
C语言练习题110例(三)
C语言练习题110例(四)
C语言练习题110例(五)
C语言练习题110例(六)
C语言练习题110例(七)
C语言练习题110例(八)
C语言练习题110例(九)
C语言练习题110例(十)
C语言练习题110例(十一)

阅读全部

相关推荐

  1. C语言深入学习 --- 5.动态内存管理

    2024-03-10 00:36:05       39 阅读

最近更新

  3. docker php8.1+nginx base 镜像 dockerfile 配置

    2024-03-10 00:36:05       94 阅读

  4. Could not load dynamic library ‘cudart64_100.dll‘

    2024-03-10 00:36:05       100 阅读

  9. 在Django里面运行非项目文件

    2024-03-10 00:36:05       82 阅读

  19. Python语言-面向对象

    2024-03-10 00:36:05       91 阅读

  20. 如何分清楚常见的 Git 分支管理策略Git Flow、GitHub Flow 和 GitLab Flow

    2024-03-10 00:36:05       85 阅读

热门阅读

  1. MySQL8.0.35 使用 show databases/show tables 时出现 ERROR 1449 (HY000) 问题的解决方法

    2024-03-10 00:36:05       40 阅读

  2. Go微服务: 基于net/rpc/jsonrpc模块实现微服务跨语言调用

    2024-03-10 00:36:05       41 阅读

  6. Rust基础教程

    2024-03-10 00:36:05       35 阅读

  11. test02

    2024-03-10 00:36:05       45 阅读

  15. c 不同类型指针的转换

    2024-03-10 00:36:05       46 阅读

  22. 【数论】欧拉筛

    2024-03-10 00:36:05       39 阅读

  23. 贪心算法介绍

    2024-03-10 00:36:05       42 阅读

  24. EDA 许可证调度

    2024-03-10 00:36:05       40 阅读

  25. Android 14.0 系统go版添加支持AppWidget小部件功能的实现

    2024-03-10 00:36:05       41 阅读

  26. ArrayList和linkedList的区别精简概述

    2024-03-10 00:36:05       53 阅读

  29. Android 11 系统开发增加低电量弹窗提示 手机 平板 车载 TV 投影 通用

    2024-03-10 00:36:05       35 阅读