A diferente pregunta inspiró el siguiente pensamiento:

Hacestd::vector<T> tene para mover todos los elementos cuando aumenta su capacidad?

egún tengo entendido, el comportamiento estándar es que el asignador subyacente solicite una porción completa del nuevo tamaño, luego mueva todos los elementos antiguos, luego destruya los elementos antiguos y luego desasigne la memoria anterior.

Este comportamiento parece ser la única solución correcta posible dada la interfaz del asignador estándar. Pero me preguntaba, ¿tendría sentido enmendar el asignador para ofrecer unareallocate(std::size_t)unción @ que devolvería unapair<pointer, bool> y podría asignarse a la @ subyacenrealloc()? La ventaja de esto sería que, en el caso de que el sistema operativo pueda simplementeamplia la memoria asignada, entonces no tendría que ocurrir ningún movimiento. 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 podemos extenderlos. De hecho, preferimos querer algo comoextend_or_malloc_new(). Editar Quizás unais_poda especialización basada en @trait nos permitiría utilizar la @ rerealloc, incluida su copia bit a bit. Simplemente no en general.)

Parece una oportunidad perdida. En el peor de los casos, siempre podría implementarreallocate(size_t n) comoreturn 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 ++?

Quizás el único contenedor que podría aprovechar esto esstd::vector, pero de nuevo es un contenedor bastante útil.

Update: Un pequeño ejemplo para aclarar. Actualresize():

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 implementación:

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

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