¿Std:: vector * tiene * que mover objetos al aumentar su capacidad? O, ¿pueden los asignadores "reasignar"?

Una pregunta diferente inspiró el siguiente pensamiento:{[17]]}

Hace std::vector<T> tiene para mover todos los elementos cuando aumenta su capacidad?

Por lo que entiendo, el comportamiento estándar es que el asignador subyacente solicite un trozo completo del nuevo tamaño, luego mueva todos los elementos antiguos, luego destruya los elementos antiguos y luego desasigne la memoria antigua.

Este comportamiento parece ser la única solución correcta posible dada la interfaz de asignador estándar. Pero me preguntaba, ¿tendría sentido modificar el asignador para ofrecer una función reallocate(std::size_t) que devolvería un pair<pointer, bool> y podría mapearse al realloc() subyacente? La ventaja de esto sería que en el caso de que el sistema operativo puede realmente solo extender la memoria asignada, entonces no tendría que suceder ningún movimiento en absoluto. El booleano indicaría si la memoria se ha movido.

(std::realloc() tal vez no sea la mejor opción, porque no necesitamos copiar datos si no se puede extender. Así que, de hecho, preferiríamos algo como extend_or_malloc_new(). Editar: Quizás una especialización basada en rasgos is_pod nos permitiría usar el realloc real, incluyendo su copia bit a bit. Pero no en general.)

Parece una oportunidad perdida. En el peor de los casos, siempre podría implementar reallocate(size_t n) como return make_pair(allocate(n), true);, por lo que no habría ninguna penalización.

¿Hay algún problema que haga que esta característica sea inapropiada o indeseable para C++?

Tal vez el único contenedor que podría tomar ventaja de esto es std::vector, pero de nuevo que es un contenedor bastante útil.

Actualización: Un pequeño ejemplo para aclarar. Corriente resize():

pointer p = alloc.allocate(new_size);

for (size_t i = 0; i != old_size; ++i)
{
  alloc.construct(p + i, T(std::move(buf[i])))
  alloc.destroy(buf[i]);
}
for (size_t i = old_size; i < new_size; ++i)
{
  alloc.construct(p + i, T());
}

alloc.deallocate(buf);
buf = p;

Nueva aplicación:

pair<pointer, bool> pp = alloc.reallocate(buf, new_size);

if (pp.second) { /* as before */ }
else           { /* only construct new elements */ }