《C和指针》阅读笔记(10)---动态内存

最新推荐文章于 2022-09-25 12:48:40 发布
最新推荐文章于 2022-09-25 12:48:40 发布
阅读量184 收藏
点赞数
分类专栏： c和指针 文章标签： c语言 malloc 指针
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43708622/article/details/110459772
版权

本文继续对《C和指针》的第11章进行解读，这一章的内容非常简单，主要介绍了4个和动态内存分配相关的系统API，怎样用好这几个API进行动态内存分配及管理才是我们需要掌握的。废话少说，干就完了！

文章目录

malloc

void *malloc(size_t size);

malloc在heap上动态分配size大小的内存，如果分配成功，则返回一个指向这块内存的指针；如果失败，则返回NULL。

作为一个c语言的程序员，一个好的编码习惯是在malloc后，立即编写free的代码，以免后面忘记，最终是程序出现内存泄漏的问题。

free

void free(void *ptr);

即释放掉前面malloc(或者其他动态内存分配函数)分配的内存，ptr表示被释放内存的地址。

按照惯例，先来一个示例程序来展示这个两个接口的简单使用。demo1.c演示了一个16字节长度的动态内存的申请与释放。

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

#define BLK_SIZE (16)

int main(int argc, char** argv)
{
    void *p = malloc(BLK_SIZE); // 申请16字节的内存
    if (NULL == p) // 判断是否申请成功
    {
        // 申请失败提示
        printf("allocate dynamic memory failed\n");
        return -1;
    }
    // 申请成功，则打印成功提示
    printf("allocate dynamic memory successfully, size is %d\n", BLK_SIZE);

    // 在实际的工程代码中，通常在释放前会对指针进行判空
    if (NULL != p)
    {
        free(p);
        p = NULL;
        printf("free dynamic memory successfully\n");
    }
    return 0;
}

我们知道，数组的大小是在编译时就确定了，而动态内存的大小是在运行时确定的。下面这个示例就说明了这一点。

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

#define BLK_SIZE (16)

int main(int argc, char** argv)
{
    int i = 0;
    // 由程序运行时通过命令行参数指定动态内存的大小
    int dy_size = atoi(argv[1]);

    //const int st_size = 16;
    //char arr[st_size] = {0};
    //需要注意，在定义数组时，在给定数组的大小时不能使用变量，否则编译器会报编译错误信息
    //error: variable-sized object may not be initialized
    char arr[BLK_SIZE] = {0};

    // 申请动态内存
    char *p = (char*)malloc(dy_size);
    if (NULL == p)
    {
        printf("allocate dynamic memory failed\n"); 
        return -1;
    }
    printf("allocate dynamic memory successfully, size is %d\n", dy_size);

    // 给数组的每个元素赋值
    for (i = 0; i < BLK_SIZE; ++i)
        arr[i] = i;

    // 给动态内存的每个元素赋值
    for (i = 0; i < dy_size; ++i)
        *(p+i) = i;

    // 打印数组的所有元素
    printf("print all elements of array:\n");
    for (i = 0; i < BLK_SIZE; ++i)
        printf("arr[%d] = %d\n", i, arr[i]);
    
    // 打印动态内存的所有元素
    printf("print all elements of dynamic memory:\n");
    for (i = 0; i < dy_size; ++i)
        printf("mem[%d] = %d\n", i, p[i]);

    if (NULL != p)
    {
        free(p);
        p = NULL;
        printf("free dynamic memory successfully\n");
    }
    return 0;
}

我们来看看两次运行的结果：(第一次命令行参数指定动态内存的大小为8，第二次命令行参数指定动态内存的大小为16)

$ ./demo2 8
allocate dynamic memory successfully, size is 8
print all elements of array:
arr[0] = 0
arr[1] = 1
arr[2] = 2
arr[3] = 3
arr[4] = 4
arr[5] = 5
arr[6] = 6
arr[7] = 7
arr[8] = 8
arr[9] = 9
arr[10] = 10
arr[11] = 11
arr[12] = 12
arr[13] = 13
arr[14] = 14
arr[15] = 15
print all elements of dynamic memory:
mem[0] = 0
mem[1] = 1
mem[2] = 2
mem[3] = 3
mem[4] = 4
mem[5] = 5
mem[6] = 6
mem[7] = 7
free dynamic memory successfully

$ ./demo2 16
allocate dynamic memory successfully, size is 16
print all elements of array:
arr[0] = 0
arr[1] = 1
arr[2] = 2
arr[3] = 3
arr[4] = 4
arr[5] = 5
arr[6] = 6
arr[7] = 7
arr[8] = 8
arr[9] = 9
arr[10] = 10
arr[11] = 11
arr[12] = 12
arr[13] = 13
arr[14] = 14
arr[15] = 15
print all elements of dynamic memory:
mem[0] = 0
mem[1] = 1
mem[2] = 2
mem[3] = 3
mem[4] = 4
mem[5] = 5
mem[6] = 6
mem[7] = 7
mem[8] = 8
mem[9] = 9
mem[10] = 10
mem[11] = 11
mem[12] = 12
mem[13] = 13
mem[14] = 14
mem[15] = 15
free dynamic memory successfully

calloc

void *calloc(size_t nmemb, size_t size);

calloc和malloc的作用类似，也是分配动态内存，但有两点不同

  • calloc的参数个数有两个，需要指定元素个数以及每个元素的大小；
  • calloc会把分配的内存初始化为0，而malloc分配的内存是随机值；

demo3.c 演示了calloc的使用，以及calloc的会初始化内存为0的特性，同时也展示了malloc分配的内存是随机值。

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

#define BLK1_SIZE (160)
#define BLK_SIZE (16)

void myfree(void *p)
{
    if (NULL != p)
    {
        free(p);
        p = NULL;
        printf("free dynamic memory successfully\n");
    }
}

int main(int argc, char** argv)
{
    int n       = 0;
    int i       = 0;
    int *p1    = NULL;
    int *p11   = NULL;
    int *p2    = NULL;

    p1 = (int*)malloc(BLK1_SIZE*sizeof(int));
    if (NULL == p1)
    {
        printf("malloc failed\n"); 
        return -1;
    }
    printf("\np1 malloc(%p) successfully, size is %ld\n", p1, BLK1_SIZE*sizeof(int));

    // 给这个大块内存赋值
    for (i = 0; i < BLK1_SIZE; ++i)
       p1[i] = i; 

    // 打印动态内存p1的所有元素
    printf("print all elements of p1 memory(%p):\n", p1);
    for (i = 0; i < BLK1_SIZE; ++i)
    {
        printf("%03d ", p1[i]);
        n++;
        if (n % BLK_SIZE == 0)
            printf("\n");
    }
    myfree(p1);
    printf("\n\n");

    n = 0;
    p11 = (int*)malloc(BLK_SIZE*sizeof(int));
    if (NULL == p11)
    {
        printf("malloc failed\n"); 
        return -1;
    }
    printf("p11 malloc(%p) successfully, size is %ld\n", p11, BLK_SIZE*sizeof(int));

    printf("print all elements of p11 memory(%p):\n", p11);
    for (i = 0; i < BLK_SIZE; ++i)
    {
        printf("%03d ", p11[i]);
        n++;
        if (n % BLK_SIZE == 0)
            printf("\n");
    }
    printf("\n");
    myfree(p11);


    n = 0;
    p2  = (int*)calloc(BLK_SIZE, sizeof(int));// 16个元素，每个元素占4个字节
    if (NULL == p1)
    {
        printf("calloc failed\n"); 
        return -1;
    }
    printf("calloc(%p) successfully, size is %ld\n", p2, BLK_SIZE*sizeof(int));

    printf("print all elements of calloc memory:\n");
    for (i = 0; i < BLK_SIZE; ++i)
    {
        printf("%03d ", p2[i]);
        n++;
        if (n % BLK_SIZE == 0)
            printf("\n");
    }
    printf("\n");

    myfree(p2);


    return 0;
}

在这里插入图片描述

绿色区域是第一次通过malloc申请了160个int大小的内存，并将这160个元素赋值(从0到159)，然后将其释放。

蓝色区域是再次通过malloc申请了16个int大小的内存，然后直接打印这块内存的值，发现这块内存的值是随机的，并没有被初始化。另外，p11的地址为p1上次申请的内存地址，也说明，p1释放后，p11申请内存时会复用之前的内存空间。

红色区域是通过calloc申请了16个int大小的内存，然后直接打印这块内存的值，发现这块内存的值都被初始化为0。

说明，打印中的内存的地址每次执行都不同。

这个例子说明了，对于malloc申请的内存，一种好的习惯是将这块内存进行初始化(使用memset)。

realloc

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

realloc可以扩大或缩小一块内存；若用于扩大，则原先内存的内容不变，新增的内存追加到原内存后，新内存是没有初始化的；若用于缩小，原内存尾部的冗余空间将被释放。如果原内存块的大小不能被改变，那么将会重新分配一块正确大小内存，并把原内存的内容拷贝到新的内存块上来，这种情况下就需要使用realloc返回的指针，原先的指针就不能再使用了，原内存会被自动释放。

如果ptr为NULL，realloc等价于malloc。

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

#define BLK_SIZE (16)

int main(int argc, char** argv)
{
    int i = 0;
    int n = 0;
    char *p1 = NULL;
    char *p2 = NULL;
    size_t cap = 0;

    p1 = (char*)malloc(BLK_SIZE);
    if (NULL == p1)
    {
        printf("allocate dynamic memory failed\n"); 
        return -1;
    }
    printf("p1(%p) malloc successfully, size is %d\n", p1, BLK_SIZE);
    for (i = 0; i < BLK_SIZE; ++i)
       p1[i] = i; 

    // 打印动态内存p1的所有元素
    printf("print all elements of p1 memory(%p):\n", p1);
    for (i = 0; i < BLK_SIZE; ++i)
    {
        printf("%03d ", p1[i]);
        n++;
        if (n % BLK_SIZE == 0)
            printf("\n");
    }
    printf("\n");


    // 扩容
    cap  = BLK_SIZE<<1;
    p2 = realloc((void*)p1, cap);
    if (NULL == p2)
    {
        printf("allocate dynamic memory failed\n"); 
        return -1;
    }
    printf("p2(%p) malloc successfully, size is %lu\n", p2, cap);

    n = 0;
    printf("print all elements of p1 memory(%p):\n", p1);
    for (size_t i = 0; i < cap; ++i)
    {
        printf("%03d ", p2[i]);
        n++;
        if (n % BLK_SIZE == 0)
            printf("\n");
    }

    free(p2);
    return 0;
}

在这里插入图片描述

从demo4的打印信息可以看出，扩容后，原内存中的数据不变。

最后，再介绍一个动态内存压缩的示例

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

#define BLK_SIZE (16)

int main(int argc, char** argv)
{
    int i = 0;
    int n = 0;
    char *p1 = NULL;
    char *p2 = NULL;
    size_t cap = 0;

    p1 = (char*)malloc(BLK_SIZE);
    if (NULL == p1)
    {
        printf("allocate dynamic memory failed\n"); 
        return -1;
    }
    printf("p1(%p) malloc successfully, size is %d\n", p1, BLK_SIZE);
    for (i = 0; i < BLK_SIZE; ++i)
       p1[i] = i; 

    // 打印动态内存p1的所有元素
    printf("print all elements of p1 memory(%p):\n", p1);
    for (i = 0; i < BLK_SIZE; ++i)
    {
        printf("%03d ", p1[i]);
        n++;
        if (n % BLK_SIZE == 0)
            printf("\n");
    }
    printf("\n");


    // 缩小
    cap  = BLK_SIZE>>1;
    p2 = realloc((void*)p1, cap);
    if (NULL == p2)
    {
        printf("allocate dynamic memory failed\n"); 
        return -1;
    }
    printf("p2(%p) malloc successfully, size is %lu\n", p2, cap);

    n = 0;
    printf("print all elements of p1 memory(%p):\n", p1);
    for (size_t i = 0; i < cap; ++i)
    {
        printf("%03d ", p2[i]);
        n++;
        if (n % BLK_SIZE == 0)
            printf("\n");
    }
    printf("\n");

    free(p2);
    return 0;
}

在这里插入图片描述

好了，动态内存分配就介绍这么多。

sif_666
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
个人C语言知识点笔记总结-pdf版
10-29
学习C语言需要理论与实践相结合，通过阅读笔记和教材，理解概念，然后通过编写和运行程序来加深理解。这份笔记涵盖了C语言的基础知识点，适合专升本复习或者初学者入门，配合足够的练习，可以有效地掌握C语言的基础...
FlashDB 文件系统
jieliangzi的博客
01-04 3144
FlashDB文件系统支持片上存储、外部存储器、操作系统文件系统接口。 FlashDB文件系统支持的底层接口有：FAL、C语言标准文件操作接口、POSIX 标准文件接口。 FlashDB 主要适用于少量数据存储的应用场景 在MCU的移植过程中主要使用FAL作为底层接口。 FAL存储底层接口说明 FAL 的作用是实现存储系统分区管理，可以对指定分区进行读写访问操作。 FAL 可以同时支持多个类型的存储器：片上FLASH、外部Nor Flash、等其他类型的存储器。 FAL移植步骤： 1.定义F
实时操作系统UCOS学习笔记15----存储管理
qq_38958704的博客
10-16 562
作为一个操作系统，内存管理是其必备的功能，在UCOSIII中也有内存管理模块，使用内存管理模块可以动态的分配和释放内存，这样可以高效的使用“昂贵”的内存资源，本章讲解一下UCOSIII的内存管理。 1、存储管理简介 内存管理是一个操作系统必备的系统模块，我们在用VC++或者visual studio学习C语言的时候会使用malloc()函数和free()函数来申请和释放内存。我们在使用MDK编写STM32程序的时候就可以使用malloc()和free()，但是不建议这么用，这样的操作会将原来大块内存逐渐的分
Linux下st_blksize与Windows下簇大小的对应
xiaohuaidan717的专栏
02-23 3257
声明：此调查结果如有错误，敬请指正。谢谢^_^ Linux下文件对应的属性struct stat {        mode_t     st_mode;        //文件对应的模式，文件、目录等        ino_t         st_ino;            //inode节点号        dev_t        st_dev;           /
python读取文件最后几行_如何用python获取文件的最后一行，文件可能会比较大
weixin_39634194的博客
11-24 278
展开全部#!/usr/bin/env pythonimport osimport sysdef get_last_n_lines(logfile, n):blk_size_max = 4096n_lines = []with open(logfile, 'rb') as fp:fp.seek(0, os.SEEK_END)cur_pos = fp.tell()while cur_pos > 0 a...
4.12 st_size、st_blksize和st_blocks成员-文件尺寸
zhoulaowu的专栏
11-05 9610
struct stat结构（参考《4.2 stat函数》）中的一些数据成员可以反应文件所占用的存储空间以及所在的文件系统参数。其中常用的有：st_blksize（文件的块大小）、st_blocks（文件包含的块数）和st_size（文件大小字节数）。 所谓块大小就是文件系统在给文件分配空间时的最小单位。文件系统并不是以字节为单位给具体文件分配存储空间，都是以一个合适大小（例如512字节等）为单位
(完整版)C语言程序设计笔记-知识点及例题.doc
11-12
C语言程序设计笔记 本笔记涵盖了C语言程序设计的知识点和例题，旨在...此外，本笔记还包括了一些高级主题的讨论，如位运算和位域、联合体和bit field、内存管理和垃圾回收等，以便读者更好地理解C语言的深层次知识。
C语言C语言-C语言笔记-B站小甲鱼
09-23
- **灵活性**：C语言提供了丰富的运算符和支持底层操作的能力，尤其是指针机制，这让程序员可以更精细地控制内存和其他资源。这种灵活性使得C语言成为很多高性能应用程序的首选语言。 - **可移植性**：C语言具有很高...
深圳大学《C语言程序设计》笔记-重点笔记
05-17
首先，笔记从C语言概述入手，讲解了C程序的结构特点，包括源代码文件的组织方式、预处理指令、函数定义和调用等。理解C程序的构建块是编写有效代码的基础。接着，详细阐述了C程序的上机步骤，从编写源代码到编译、...
2023-04-06-项目笔记-第一阶段-14.指针 14.1内存
最新发布
01-15
2023-04-06-项目笔记-第一阶段- 9.函数 9.1函数的使用 10.数组 10.1.数组的使用 11.操作符 11.1操作符的使用 12.常见关键字 12.1关键字 typedef 12.2关键字static 12.2.1修饰局部变量 12.2.2修饰全局...指针 14.1内存
参数block_size介绍
msdnchina的专栏@JiNan,ShanDong
01-25 2430
参数名称 block_size 数据类型 int 默认值 8192B，也就是8KB 参数取值 参数含义 数据库使用的disk block的大小，该参数也影响其他的配置参数，比如shared_buffers 参数确定时机 编译时./configure命令的--with-blocksize选项 ...
linux文件分区 簇大小,Linux下st_blksize与Windows下簇大小的对应
weixin_42306501的博客
05-03 700
声明：此调查结果如有错误，敬请指正。谢谢^_^Linux下文件对应的属性struct stat {mode_t st_mode; //文件对应的模式，文件、目录等ino_t st_ino; //inode节点号dev_t st_dev; //设备号码dev_t st_rdev;...
关于MVS的blksize
Simon's Tech Book
05-09 2180
blksize就是，大机在做一次IO操作时，一次读写的单位。这个一定要是记录长度（lrecl）的整数倍。原因很简单，不是整数倍的话，就会造成一次I/O操作会截断数据记录。对于通常的3390设备，建议一个blk给的最优计算公式为：INT(27998/LRECL)*LRECL原因是3390设备的一个块是27988byte，上面的公式可以算出最接近一个磁盘块，但又在一个块之中的blksize大小
RT-Thread 隐藏的宝藏之ringblk
whj123999的博客
03-14 1325
一. ring blk 是什么 大家应该经常会听到 ringbuff , 那 ringblk(环形块缓冲区) 是什么呢？ ringblk 也是环形缓冲区，但是他的缓冲区的单位是一个 block , 每次对数据的操作都是以 block 为单位。 二. ringblk 怎么使用 ringblk 的使用先要创建环形块缓冲区，通过 alloc 申请到块之后，通过 put 写数据到缓冲区，通过 get 从缓冲区中获取数据。对于不需要在用的块，通过 free 释放。 连续的 block 可以组成 块队列。 1. 创建块
扇区与块（sectors,block）
热门推荐
terryliu98的专栏
05-21 1万+
净下心来总结点东西。
【C语言】解析动态内存分配函数——malloc()函数、calloc()函数、realloc()函数
努力
09-25 792
解析动态内存分配函数malloc()函数、calloc()函数、realloc()函数
C语言中内存管理（函数）（malloc、free、calloc、realloc）
qq_38769551的博客
11-28 260
实例： // c_memory_test.c #include <stdio.h> #include <stdlib.h> #include <string.h> int main() { char *p_str1, *p_str2; // 定义两个char*指针 /* 使用malloc()函数分配内存 */ p_...
野指针：释放内存但却仍然使用它，将导致野指针
梦醒已隔万重秋的博客
05-26 1299
/************ 野指针：释放内存但却仍然使用它，将导致野指针 *************/ /* 例子：输入一个不带空格的字符串显示在屏幕上 */ #include char *GetStr(void) {     char s[80];     scanf("%s",s);     //printf("s = %p\n",s);        //打印返
计算机组成原理：CPU---计算机的大脑
OceanStar的博客
11-27 3067
比如说一个4核芯片上面承载了4个微型芯片，每个微型芯片上都有自己独立的CPU。多个CPU可以让多个程序并发的运行。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

sif_666

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值