are there center-allocation deque or vector in STL implementations? - c++

Question

I was reading about deques vs vectors, and came across its wikipedia entry, which says one of the three possible implementations of deque using dynamic arrays is:
Allocating deque contents from the center of the underlying array, and
resizing the underlying array when either end is reached. This
approach may require more frequent resizings and waste more space,
particularly when elements are only inserted at one end.
I was wondering if there are any STL (or STL-style) implementations that actually use this center-allocation strategy?
I am asking because this strategy looks rather appealing as it involves only one underlying array, and thus removes the memory dis-contiguity issue, which is probably the only major issue deque has when compared to vector. If I understand it right, this could well be a replacement for std::vector that allows O(1) pop_front (amortized) or a replacement for deque with memory-contiguity guarantees. I assume that this is at the cost of doubling the buffering space of a std::vector, which is not a major concern for my use cases.
Also, is it true that insertion/deletion in the middle of such a container would take half the time of std::vector on average?
UPDATE:
As #Lightness Races in Orbit pointed out, such a implementation will not be used under current standards because no one can benefit from the upsides per contract with STL and everyone will suffer from the downsides. A further question I have regarding the downsides is this:
Is it possible to implement a new vector or deque like container (say bivector) such that in addition to the functionality/operators of std::vector,
1) provides (amortized) constant time push_front() and pop_front() operations and
2) guarantees memory contiguity but not iterator validity after growing sizes?
I imagine with one array behind the scene, a lot of the indirection/performance issues on deque would go away.

Answer 1

No Standard Library (not "STL") implementation is going to bother with this, because it has the downsides you mention, and the upsides are not part of the requirement for std::deque.
Those requirements are carefully constructed, right from algorithmic complexity for various operations, through to iterator invalidation rules. There is no benefit in implementing a container in such a way that nobody can rely on that implementation's upsides.
Could the C++ committee introduce a new container in a future standard with a different name and with different constraints, which vendors could implement as you describe? Yes, they could.

Answer 2

Your problem is you lack that container. Start with something like this:
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();
}
}
};
and add iterators (I'd be tempted to use boost iterator helpers, or raw pointers to start) and whatever interfaces you need. Note that the above needs work to ensure it remains exception safe.