正在寻找填充std:：list的快速方法 我有一个VisualStudio 2008 C++程序，我用内存池的地址填充了 STD:：列表。p>

我有一个使用

std:：generate

工作的实现，它还不错，但是对于小分配块的大型池来说，它可能有点慢

/// fill the allocation list with the memory addresses of each block
struct fill
{
    fill( void* start, ulong alloc ) 
        : start_( start ), 
          alloc_( alloc ), 
          count_( 0 ) 
    {
    };

    void* operator()()
    {
        return ( void* )( ( ulong ) start_ + ( count_++ ) * alloc_ );
    }

    /// starting address
    void* start_;
    /// size of the blocks
    ulong alloc_;
    /// internal counter
    int count_;
}; // struct fill

ulong begin = 0;            // beginning address
ulong max_size = 0x1000;    // maximum memory pool size (4KB)
ulong block_size = 0x20;    // size of each memory block (32B)

std::list< void* > memory;
memory.resize( max_size / block_size ); // 128 memory blocks
std::generate( memory.begin(), memory.end(), fill( begin, block_size ) );

///用每个块的内存地址填充分配列表
结构填充
{
填充（空*开始，ulong alloc）
：开始(开始)，
alloc_（alloc），
计数（0）
{
};
void*运算符（）
{
返回（void*）（（ulong）开始（count）+*alloc）；
}
///起始地址
void*开始u；
///区块大小
ulong alloc；
///内部计数器
整数计数；
}; // 结构填充
ulong begin=0；//起始地址
ulong max_size=0x1000；//最大内存池大小（4KB）
ulong块大小=0x20；//每个内存块的大小（32B）
标准：：列表内存；
内存。调整大小（最大大小/块大小）；//128个内存块
std:：generate（memory.begin（）、memory.end（）、fill（begin、block_size））；

我只是想知道是否有人有一个更快或更有效的方法来填写链接列表

谢谢，

---

PaulH

您的代码在列表中传递两次，而不是一次

因此，它可能有助于定义一个迭代器来返回地址，以便在一次传递中完成所有操作：

struct blocks {
    void *current;
    size_t increment;

    blocks(void* start, size_t size = 0) : current(start), increment(size) {}

    bool operator==(const blocks &rhs) const { return current == rhs.current; }
    bool operator!=(const blocks &rhs) const { return current != rhs.current; }
    void *operator*() const { return current; }
    blocks &operator++() {
        current = (void*)( (char*)current + increment );
        return *this;
    }
};

std::list<void*> memory(blocks(begin, block_size), blocks(max_size));

struct块{
无效*当前；
尺寸增量；
块（void*start，size\u t size=0）：当前（开始），增量（大小）{}
布尔运算符==（常量块和rhs）常量{返回当前==rhs.current；}
布尔运算符！=（常数块和rhs）常数{返回电流！=rhs.current；}
void*运算符*（）常量{return current；}
块和运算符++（）{
当前=（无效*）（（字符*）当前+增量）；
归还*这个；
}
};
列表内存（块（开始，块大小），块（最大大小））；

（代码没有经过测试，为了成为一个合适的迭代器，我省略了一些您需要的东西——如果没有其他东西的话，它需要标记，并且通常欢迎后期增量。）

目前它只是一个ForwardIterator（或者，如果它被标记的话，它将是）。您可以很容易地使其成为RandomAccessIterator，但必须为end iterator提供正确的大小。如果您使用

char（*）[block\u size]

的容器而不是

void*

的容器，那么我认为您可以使用

boost:：counting\u迭代器来填充它

但是，从根本上说，
std:：list
在这一点上有点慢。除非你要在中间插入/删除（这对于内存池空闲列表来说是不必要的）——如果所有的块都是相同的大小，那么你应该总是能够在最后添加和删除），你可以用向量或者DeQuy做得更好，或者至少使用侵入式链表。
为什么要使用
列表
而不是
向量
？慢到底意味着什么？您正在分配128个小内存块。不管数据结构如何，这应该是非常快的。这一努力似乎被误导了<代码> STD:：清单将为每个节点做它自己的分配，所以你的内存池不会保存任何东西（它可能会比正常分配慢），但是它并没有严格地与列表相关，但是你考虑过LoKi小对象分配器吗？对于那些需要上下文的：史提夫，不是代码> STD:：列表< /代码>一个链表本身？您不需要实现
操作符=？@Nawaz：（1）是的，但它不是一个侵入性的链表。（2） 是的，这种缺失几乎肯定会阻止
列表
构造函数的编译，因此我将添加它。我已经切换到
std:：deque
，并实现了您使用迭代器构造函数的巧妙方法。速度更快，谢谢！哦。。我不知道术语。谢谢和+1