STL 实现中是否有中心分配双端队列或向量？

Question

我正在阅读有关 deques 与 vectors 的文章，并遇到了它的 wikipedia entry，它说使用动态数组的 deque 的三种可能实现之一是：

从底层数组的中心分配双端队列内容，以及 到达任一端时调整底层数组的大小。这 方法可能需要更频繁地调整大小并浪费更多空间， 特别是当元素只插入一端时。

我想知道是否有任何 STL（或 STL 风格）实现实际使用这种中心分配策略？

我之所以这么问是因为这个策略看起来相当吸引人，因为它只涉及一个底层数组，因此消除了内存不连续问题，这可能是deque 与vector 相比的唯一主要问题。如果我理解正确，这很可能是 std::vector 的替代品，它允许 O(1) pop_front（摊销）或 deque 的替代品，具有内存连续性保证。我假设这是以将std::vector 的缓冲空间增加一倍为代价的，这对我的用例来说不是一个主要问题。

另外，在这样的容器中间插入/删除是否会平均花费 std::vector 一半的时间？

---

更新：

正如@Lightness Races in Orbit 指出的那样，在当前标准下不会使用这样的实现，因为没有人可以从与 STL 的每份合同中受益，而每个人都会受到不利影响。关于缺点，我还有一个问题是：

是否可以实现一个新的 vector 或 deque 类似容器（比如bivector），这样除了std::vector 的功能/操作符之外，

1) 提供（摊销的）恒定时间push_front() 和pop_front() 操作和

2) 在增加大小后保证内存连续性但不保证迭代器有效性？

我想在幕后使用一个数组，deque 上的许多间接/性能问题都会消失。

Answer 1

你的问题是你缺少那个容器。从这样的开始：

template<typename T>
class bi_vec {
  std::unique_ptr<char[]> raw;
  std::size_t first = 0;
  std::size_t last = 0;
  std::size_t capacity = 0;
  char* raw_get( std::size_t index ) {
    return &raw[index*sizeof(T)];
  }
  char const* raw_get( std::size_t index ) const {
    return &raw[index*sizeof(T)];
  }
  T& get( std::size_t index ) {
    return *reinterpret_cast<T*>(raw_get(index));
  }
  T const& get( std::size_t index ) const {
    return *reinterpret_cast<T const *>(raw_get(index));
  }
  char* raw_before() {
    if (first < 1)
      grow();
    --first;
    return raw_get(first);
  }
  char* raw_after() {
    if (last+1 >= capacity)
      grow();
    ++last;
    return raw_get(last-1);
  }
  void grow() {
    std::vector new_capacity = (capacity+1)*2;
    std::size_t new_first = (new_capacity - (last-first)) / 2;
    std::size_t new_last = new_capacity - new_first;
    std::unique_ptr<char[]> new_buff( new char[new_capacity*sizeof(T)] );
    T* b = &get(0);
    T* e = &get(last-first);
    std::move( b, e, reinterpret_cast<T*>( &new_buff[new_first*sizeof(T)] ) );
    std::swap( buff, raw );
    std::swap( new_capacity, capacity );
    std::swap( new_first, first );
    std::swap( new_last, last );
    for (T* it = b; it != e; ++it) {
      it->~T();
    }
  }
public:
  T& operator[]( std::size_t index ) { return get(index); }
  T const& operator[]( std::size_t index ) const { return get(index); }
  template<class... Us>
  void emplace_back( Us&&...us ) {
    char* a = raw_after();
    new (a) T( std::forward<Us>(us) );
  }
  template<class... Us>
  void emplace_front( Us&&...us ) {
    char* a = raw_before();
    new (a) T( std::forward<Us>(us) );
  }
  ~bi_vec() {
    for( std::size_t i = 0; i != last-first; ++i ) {
      get(i).~T();
    }
  }
};

并添加迭代器（我很想使用boost 迭代器助手，或原始指针来启动）和您需要的任何接口。请注意，上述内容需要工作以确保其保持异常安全。

Answer 2

没有标准库（不是“STL”）实现会为此烦恼，因为它有你提到的缺点，而优点不是std::deque 要求的一部分。

从各种操作的算法复杂性到迭代器失效规则，这些要求都是经过精心构建的。以这样一种方式实现容器没有任何好处，以至于没有人可以依赖该实现的好处。

C++ 委员会能否在未来的标准中引入一个具有不同名称和不同约束的新容器，哪些供应商可以按照您的描述实现？是的，他们可以。