linux笔记（）—— malloc函数详解

Bertha 。 2022-05-16 04:06 686阅读 0赞

**一、原型：extern void \*malloc(unsigned int num\_bytes);**

头文件：\#include <malloc.h> 或 \#include <alloc.h> (注意：alloc.h 与 malloc.h 的内容是完全一致的。)

功能：分配长度为num\_bytes字节的内存块

说明：如果分配成功则返回指向被分配内存的指针，否则返回空指针NULL。

当内存不再使用时，应使用free()函数将内存块释放。

**二、函数声明(函数原型)：**

void \*malloc(int size);

说明：malloc 向系统申请分配指定size个字节的内存空间。返回类型是 void\* 类型。void\* 表示未确定类型的指针。C,C++规定，void\* 类型可以强制转换为任何其它类型的指针。这个在MSDN上可以找到相关的解释，具体内容如下

**三、malloc与new的不同点**

从函数声明上可以看出。malloc 和 new 至少有两个不同: ***new 返回指定类型的指针，并且可以自动计算所需要大小。***比如：

int \*p;

p = new int; //返回类型为int\* 类型(整数型指针)，分配大小为 sizeof(int);

或：

int\* parr;

parr = new int \[100\]; //返回类型为 int\* 类型(整数型指针)，分配大小为 sizeof(int) \* 100;

***而 malloc 则必须由我们计算要字节数，并且在返回后强行转换为实际类型的指针。***

int\* p;

p = (int \*) malloc (sizeof(int));

第一、malloc 函数返回的是 void \* 类型，如果你写成：p = malloc (sizeof(int)); 则程序无法通过编译，报错：“不能将 void\* 赋值给 int \* 类型变量”。所以必须通过 (int \*) 来将强制转换。

第二、函数的实参为 sizeof(int) ，用于指明一个整型数据需要的大小。如果你写成：

int\* p = (int \*) malloc (1);

代码也能通过编译，但事实上只分配了1个字节大小的内存空间，当你往里头存入一个整数，就会有3个字节无家可归，而直接“住进邻居家”！造成的结果是后面的内存中原有数据内容全部被清空。

malloc 也可以达到 new \[\] 的效果，申请出一段连续的内存，方法无非是指定你所需要内存大小。

比如想分配100个int类型的空间：

int\* p = (int \*) malloc ( sizeof(int) \* 100 ); //分配可以放得下100个整数的内存空间。

另外有一点不能直接看出的区别是，malloc 只管分配内存，并不能对所得的内存进行初始化，所以得到的一片新内存中，其值将是随机的。

除了分配及最后释放的方法不一样以外，通过malloc或new得到指针，在其它操作上保持一致。

** 总结：**

malloc()函数其实就在内存中找一片指定大小的空间，然后将这个空间的首地址范围给一个指针变量，这里的指针变量可以是一个单独的指针，也可以是一个数组的首地址，这要看malloc()函数中参数size的具体内容。我们这里malloc分配的内存空间在逻辑上连续的，而在物理上可以连续也可以不连续。对于我们程序员来说，我们关注的是逻辑上的连续，因为操作系统会帮我们安排内存分配，所以我们使用起来就可以当做是连续的。

**四、Linux内存管理**

**4.1 虚拟内存地址与物理内存地址**

为了简单，现代操作系统在处理内存地址时，普遍采用虚拟内存地址技术。即在汇编程序（或机器语言）层面，当涉及内存地址时， 都是使用虚拟内存地址。采用这种技术时，每个进程仿佛自己独享一片2N字节的内存，其中N是机器位数。例如在64位CPU和64位操作系统下，每个进程的 虚拟地址空间为264Byte。

这种虚拟地址空间的作用主要是简化程序的编写及方便操作系统对进程间内存的隔离管理，真实中的进程不太可能（也用不到）如此大的内存空间，实际能用到的内存取决于物理内存大小。

由于在机器语言层面都是采用虚拟地址，当实际的机器码程序涉及到内存操作时，需要根据当前进程运行的实际上下文将虚拟地址转换为物理内存地址，才能实现对真实内存数据的操作。这个转换一般由一个叫[MMU][]（Memory Management Unit）的硬件完成。

4.2.什么是页表？

在现代操作系统中，不管是虚拟内存地址还是物理内存地址，**都是以页尾单位管理的，而不是大家以为的字节。**（一个内存页是一段固定的地址，典型的内存页的大小是4K）。所以内存地址可以分为页号和页内偏移量

。![Center][]

**五，Linux进程级的内存管理**

首先，我们可以了解一下一个进程的内核空间：

![Center 1][]

可以看到一个进程地址空间的主要成分为：

*  正文：这是整个用户空间的最低地址部分，存放的是指令（也就是程序所编译成的可执行机器码）
 *  初始化数据段：这里存放的是初始化过的全局变量
 *  未初始化数据段：这里存放的是未初始化的全局变量
 *  Heap：堆，这是我们本文重点关注的地方，堆自低地址向高地址增长，后面要讲到的brk相关的系统调用就是从这里分配内存
 *  Stack：这是栈区域，自高地址向低地址增长
 *  命令行参数和环境变量：用户调用的最底层。

我们都知道，在malloc分配空间时是在Heap上分配的，实质上，Linux维护一个break指针，这个指针指向堆空间的某个地址。从堆起始地址到break之间的地址空间为映射好的，可以供进程访问；而从break往上，是未映射的地址空间，如果访问这段空间则程序会报错。

![Center 2][]

由上文知道，要增加一个进程实际的可用堆大小，就需要将break指针向高地址移动。Linux通过brk和sbrk系统调用操作break指针。两个系统调用的原型如下：

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>int brk(void *addr);<br> void *sbrk(intptr_t increment);</td> 
  </tr> 
 </tbody> 
</table>

brk将break指针直接设置为某个地址，而sbrk将break从当前位置移动increment所指定的增量。brk在执行成功时返回0，否则返回-1并设置errno为ENOMEM；sbrk成功时返回break移动之前所指向的地址，否则返回(void \*)-1。

一个小技巧是，如果将increment设置为0，则可以获得当前break的地址。

另外需要注意的是，由于Linux是按页进行内存映射的，所以如果break被设置为没有按页大小对齐，则系统实际上会在最后映射一个完整的页，从而实际已映射的内存空间比break指向的地方要大一些。但是使用break之后的地址是很危险的（尽管也许break之后确实有一小块可用内存地址）。

有了上面的知识，我们可以实现一个最简单的malloc（没什么用，像个玩具）

/* 一个玩具malloc */
    #include <sys/types.h>
    #include <unistd.h>
    void *malloc(size_t size)
    {
        void *p;
        p = sbrk(0);
        if (sbrk(size) == (void *)-1)
            return NULL;
        return p;
    }

这个malloc由于对所分配的内存缺乏记录，不便于内存释放，所以无法用于真实场景。

**六，开始实现正式的malloc**

一个方案是将堆内存空间以块（Block）的形式组织起来，每个块由meta区和数据区组成，meta区记录数据块的元信息（数据区大小、空闲标志位、指针等等），数据区是真实分配的内存区域，并且数据区的第一个字节地址即为malloc返回的地址。

以下是一个块的结构：

typedef struct s_block *t_block;
    struct s_block {
        size_t size;  /* 数据区大小 */
        t_block next; /* 指向下个块的指针 */
        int free;     /* 是否是空闲块 */
        int padding;  /* 填充4字节，保证meta块长度为8的倍数 */
        char data[1]  /* 这是一个虚拟字段，表示数据块的第一个字节，长度不应计入meta */
    };

现在考虑如何在block链中查找合适的block。一般来说有两种查找算法：

*  First fit：从头开始，使用第一个数据区大小大于要求size的块所谓此次分配的块
 *  Best fit：从头开始，遍历所有块，使用数据区大小大于size且差值最小的块作为此次分配的块

两种方法各有千秋，best fit具有较高的内存使用率（payload较高），而first fit具有更好的运行效率。这里我们采用first fit算法。

* First fit */
    t_block find_block(t_block *last, size_t size) {
        t_block b = first_block;
        while(b && !(b->free && b->size >= size)) {
            *last = b;
            b = b->next;
        }
        return b;
    }

ind\_block从frist\_block开始，查找第一个符合要求的block并返回block起始地址，如果找不到这返回NULL。这里在遍历时会更新一个叫last的指针，这个指针始终指向当前遍历的block。这是为了如果找不到合适的block而开辟新block使用的。

如果现有block都不能满足size的要求，则需要在链表最后开辟一个新的block。这里关键是如何只使用sbrk创建一个struct：

#define BLOCK_SIZE 24 /* 由于存在虚拟的data字段，sizeof不能正确计算meta长度，这里手工设置 */
     
    t_block extend_heap(t_block last, size_t s) {
        t_block b;
        b = sbrk(0);
        if(sbrk(BLOCK_SIZE + s) == (void *)-1)
            return NULL;
        b->size = s;
        b->next = NULL;
        if(last)
            last->next = b;
        b->free = 0;
        return b;
    }

First fit有一个比较致命的缺点，就是可能会让很小的size占据很大的一块block，此时，为了提高payload，应该在剩余数据区足够大的情况下，将其分裂为一个新的block：

void split_block(t_block b, size_t s) {
        t_block new;
        new = b->data + s;
        new->size = b->size - s - BLOCK_SIZE ;
        new->next = b->next;
        new->free = 1;
        b->size = s;
        b->next = new;
    }

有了上面的代码，我们可以利用它们整合成一个简单但初步可用的malloc。注意首先我们要定义个block链表的头first\_block，初始化为NULL；另外，我们需要剩余空间至少有BLOCK\_SIZE + 8才执行分裂操作。

由于我们希望malloc分配的数据区是按8字节对齐，所以在size不为8的倍数时，我们需要将size调整为大于size的最小的8的倍数：

size_t align8(size_t s) {
        if(s & 0x7 == 0)
            return s;
        return ((s >> 3) + 1) << 3;
    }
    #define BLOCK_SIZE 24
    void *first_block=NULL;

void *malloc(size_t size) {
        t_block b, last;
        size_t s;
        /* 对齐地址 */
        s = align8(size);
        if(first_block) {
            /* 查找合适的block */
            last = first_block;
            b = find_block(&last, s);
            if(b) {<pre name="code" class="cpp">         /* 如果可以，则分裂 */
                if ((b->size - s) >= ( BLOCK_SIZE + 8))
                    split_block(b, s);
                b->free = 0;
            } else {
                /* 没有合适的block，开辟一个新的 */
                b = extend_heap(last, s);
                if(!b)
                    return NULL;
            }
        } else {
            b = extend_heap(NULL, s);
            if(!b)
                return NULL;
            first_block = b;
        }
        return b->data;
    }

转自：[https://blog.csdn.net/leex\_brave/article/details/51684755][https_blog.csdn.net_leex_brave_article_details_51684755]

[https://blog.csdn.net/xw13106209/article/details/4962479][https_blog.csdn.net_xw13106209_article_details_4962479]

[MMU]: http://en.wikipedia.org/wiki/Memory_management_unit
[Center]: /images/20220516/c3f126641c034cc6bc15cba396f7d6cf.png
[Center 1]: /images/20220516/9c170fe40eda4c5a9c73e776ce221594.png
[Center 2]: /images/20220516/e3bb804110904f7bb9ccc52afa2377c6.png
[https_blog.csdn.net_leex_brave_article_details_51684755]: https://blog.csdn.net/leex_brave/article/details/51684755
[https_blog.csdn.net_xw13106209_article_details_4962479]: https://blog.csdn.net/xw13106209/article/details/4962479