具有快速连续范围检索的数据结构

想象一下数据结构，它操纵一些连续的容器，并允许快速检索该数组中包含数据（可能还有空闲范围）的连续索引范围。让我们把这个范围称为"块"。每个区块都知道它的头和尾索引：

struct Block
{
    size_t begin;
    size_t end;
}

当我们操纵数组时，我们的数据结构会更新块：

    array view          blocks [begin, end]
--------------------------------------------------------------
0 1 2 3 4 5 6 7 8 9     [0, 9]
pop 2                   block 1 splitted
0 1 _ 3 4 5 6 7 8 9     [0, 1] [3, 9]
pop 7, 8                block 2 splitted
0 1 _ 3 4 5 6 _ _ 9     [0, 1] [3, 6] [9, 9]
push 7                  changed end of block 3
0 1 _ 3 4 5 6 7 _ 9     [0, 1] [3, 7] [9, 9]
push 5                  error: already in
0 1 _ 3 4 5 6 7 _ 9     [0, 1] [3, 7] [9, 9]
push 2                  blocks 1, 2 merged
0 1 2 3 4 5 6 7 _ 9     [0, 7] [9, 9]

甚至在分析之前，我们就知道块检索速度将是应用程序性能的基石。基本用途是：

• 经常检索连续块
• 非常罕见的插入/删除
• 大多数时候，我们希望块的数量是最小的（防止碎片）

我们已经尝试过：

1. std::vector<bool>+std::list<Block*>。每次更改时：将true/false写入vector，然后遍历它进行循环并重新生成list。在块的每个查询上返回CCD_ 5。比我们想要的要慢。

2. std::list<Block*>直接更新列表，因此不需要遍历。退货清单。要调试/测试的代码很多。

问题：

1. 这个数据结构有通用名称吗
2. 是否已经实现（调试和测试）了这样的数据结构
3. 如果没有，您对快速、稳健地实现此类数据结构有何建议

对不起，我的解释不太清楚。

编辑

此容器的典型应用程序是管理缓冲区：系统或GPU内存。在GPU的情况下，我们可以在单顶点缓冲区中存储大量数据，然后更新/无效一些区域。在每次绘制调用中，我们必须知道要绘制的缓冲区中每个有效块的第一个和最后一个索引（通常，每秒十分之一到数百次），有时（每秒一次）我们必须插入/删除数据块。

另一个应用程序是自定义的"块内存分配器"。为此，类似的数据结构在"Alexandrescu A.-现代C++设计"一书中通过侵入式链表实现。我正在寻找更好的选择。