FreeRTOS 实时操作系统———”堆“是什么

堆（Heap）和栈（Stack）是两种不同的内存管理方式，它们的区别主要在于如何分配和管理内存。

• 栈：栈是操作系统自动分配的内存空间，用于存放局部变量和函数调用信息。当一个函数被调用时，局部变量会被压入栈中，当函数结束时，这些变量会自动释放。栈的特点是后进先出，内存分配是连续的，因此效率高，但空间有限。

• 堆：堆是由程序员通过动态内存分配函数（如 malloc()、new 等）分配的内存区域。当你不再需要这块内存时，必须显式释放它（通过 free() 或 delete）。堆的空间比栈大，但由于其分配和释放不是自动进行的，效率较低。

下面总结韦东山的FreeRTOS入门与工程实践 --由浅入深带你学习FreeRTOS视频，讲解一下什么是堆。

#include <iostream>
using namespace std;

char heap_buf[1024];  // 定义一个固定大小的数组，模拟堆的内存空间
int pos = 0;          // 用于记录当前堆内存的分配位置

// 模拟 malloc 函数，从堆中分配指定大小的内存
void *my_malloc(int size) 
{
    if (pos + size > 1024) { 
        // 如果分配的内存超过了 heap_buf 的大小，则返回空指针，表示分配失败
        return nullptr;
    }

    int old_pos = pos;    // 保存当前的分配起始位置
    pos += size;          // 移动指针，标记分配了 size 大小的内存
    return &heap_buf[old_pos];  // 返回指向分配内存的指针
}

// 模拟 free 函数（此处未实现）
void my_free(void *buf) 
{
    // 空的实现，因为在这个简单的堆模拟中没有释放的逻辑
    // 在实际的堆中，释放内存需要知道具体的块大小和起始地址
}

int main(void) 
{
    // 分配 100 字节的内存
    char *buf = (char*)my_malloc(100);  
    if (!buf) {
        cout << "堆内存分配失败！" << endl;
        return -1;
    }

    // 填充数据到分配的内存中，存放 'A' 到 'Z' 共 26 个字符
    for (int i = 0; i < 26; i++) {
        buf[i] = 'A' + i;  // 将 'A' 到 'Z' 存入 buf 中
    }

    // 打印内存中的字符
    for (int i = 0; i < 26; i++) {
        cout << buf[i] << " ";
    }
    cout << endl;

    // 程序结束，未调用 my_free 因为该函数未实现释放逻辑
    return 0;
}

        这个代码可以在一定程度上模拟堆内存的分配，但缺少真正的内存释放机制。你通过一个固定大小的数组 heap_buf[1024] 来模拟堆，并且通过 my_malloc() 函数按需分配内存，这部分是模拟堆分配的一个简单方式。但是，代码中的 my_free() 函数并没有实际实现释放逻辑，因此无法真正模拟堆的释放功能。

目前代码的运行逻辑

1. heap_buf[1024] 是一个大小为 1024 字节的静态数组，用来模拟堆内存空间。
2. my_malloc() 函数负责从 heap_buf 中按 size 参数分配指定大小的内存，分配后 pos 的值增加，以便下次分配时不会覆盖之前的内存空间。
3. 由于没有实现 my_free() 函数，所以当前的设计是单向分配的，无法回收已经分配的空间。

改进与模拟堆释放功能

为了模拟一个简单的堆，还需要一些改进，尤其是实现 my_free() 函数。我们可以通过更复杂的方式来追踪每次分配的块大小、起始地址等，但为了简单起见，可以做一些假设：比如每次释放的内存都是最近一次分配的，这样可以模拟一个**后进先出（LIFO）**的堆内存管理。

改进后的代码

#include <iostream>
using namespace std;

char heap_buf[1024];  // 模拟堆空间
int pos = 0;          // 当前堆内存分配指针

void *my_malloc(int size)
{
    // 检查是否有足够的空间
    if (pos + size > 1024) {
        return nullptr; // 如果空间不够，返回空指针
    }

    int old_pos = pos;
    pos += size;
    return &heap_buf[old_pos];
}

void my_free(void *buf)
{
    // 简单的 LIFO 模拟释放
    // 假设我们只能释放最近分配的块
    // 在这个简单模拟中，我们不追踪具体分配块，只能逐步释放最近的分配

    if ((char*)buf >= heap_buf && (char*)buf < heap_buf + 1024) {
        // 将pos指针返回到被释放块的起始位置
        pos = (char*)buf - heap_buf;
    }
}

int main(void)
{
    // 分配 100 字节
    char *buf = (char*)my_malloc(100);
    if (!buf) {
        cout << "堆空间不足！" << endl;
        return -1;
    }

    // 用字符填充分配的内存
    for (int i = 0; i < 26; i++) {
        buf[i] = 'A' + i;
    }

    // 打印结果
    for (int i = 0; i < 26; i++) {
        cout << buf[i] << " ";
    }
    cout << endl;

    // 释放内存
    my_free(buf);

    // 再次分配
    char *buf2 = (char*)my_malloc(50);
    if (buf2) {
        cout << "成功分配 50 字节。" << endl;
    } else {
        cout << "堆空间不足！" << endl;
    }

    return 0;
}

改进后的功能说明

1. 内存分配 (my_malloc)：如果有足够空间则分配指定大小的内存，并返回相应的地址。如果空间不足，返回 nullptr。
2. 内存释放 (my_free)：该版本的 my_free() 简单地将 pos 指针退回到最近一次分配的内存块起始地址，以模拟释放操作。这种方式只能释放最近分配的内存，无法释放任何非最近的分配。
3. 重新分配内存：当内存释放后，可以再分配新的内存块，类似于真实的堆操作，但这种简化实现不支持复杂的内存管理。