Question

我正在尝试使用双向链表数据结构在缓冲区管理器中实现替换策略。

但我的C程序没有链表库，所以我只是自己定义了数据结构。

问题是：我可以避免使用任何[动态？]内存分配来使用双向链表吗？

使用palloc()代替malloc()有什么好处？

Answer 1

你当然可以在不使用动态内存分配的情况下创建双向链表;这样做只是一种常规。

#include <stdio.h>
#include <assert.h>
#include <inttypes.h>

enum { NODEBUG = 0, DEBUG = 1 };

static const int debug = NODEBUG;

typedef struct DList DList;
struct DList
{
    int    data;
    DList *next;
    DList *prev;
};

enum { MAX_DLIST = 100 };
struct DList dlist[MAX_DLIST];

static void add_node(DList *head, DList *node)
{
    assert(head != 0 && node != 0);
    if (head->next == 0)
    {
        assert(head->prev == 0);
        head->next = node;
        head->prev = node;
        node->next = head;
        node->prev = head;
    }
    else
    {
        assert(head->prev != 0);
        node->next = head->next;
        node->prev = head;
        head->next->prev = node;
        head->next = node;
    }
}

static void diagnode(DList *node)
{
    if (debug)
        printf(" (T = 0x%.12" PRIXPTR ", N = 0x%.12" PRIXPTR ", P = 0x%.12" PRIXPTR ")\n",
               (uintptr_t)node, (uintptr_t)node->next, (uintptr_t)node->prev);
}

static void print_list(DList *head)
{
    assert(head != 0);
    printf("List:");
    if (head->next != 0)
    {
        DList *node;
        int counter = 0;
        if (debug)
            printf("\nHEAD");
        diagnode(head);
        for (node = head->next; node != head; node = node->next)
        {
            printf(" %3d", node->data);
            diagnode(node);
            assert(counter++ < MAX_DLIST);
        }
    }
    printf(" <EOL>\n");
}

int main(void)
{
    DList head = { 0, 0, 0 };

    for (int i = 0; i < MAX_DLIST; i++)
    {
        dlist[i].data = (i * 13 + 7) % 100;
        add_node(&head, &dlist[i]);
        if (debug)
            print_list(&head);
    }
    print_list(&head);
}

看不到内存分配！当你有一个类似缓冲区管理器的东西时，你可以使用这种变体，其中有一个固定的数据缓冲区数组，但你想要一个LRU（最近最少使用的）替换策略。而不是像本例中那样直接在双向链表结构中使用数据，data元素将指向缓冲池中的条目。然后，您可以在列表中添加和删除条目，而无需更改列表链接到的主数据结构中的任何内容。

如果palloc()是池内存分配器，则使用它malloc()的优点是，您可以通过单个函数调用释放分配给给定池的所有内存，而不必管理所有的单独释放你自己。有时，池分配器比使用malloc()的单独内存分配更有效;它可能会分配一个固定大小结构的大数组，然后根据请求发送条目，减少分配数量，从而减少开销。

我们可以在没有动态内存分配的情况下在C中使用双向链表吗？

1 个答案: