c++ - sellos - tipos de contenedores

Cómo verificar si un contenedor es estable

Question

std::vector es un contenedor inestable, es decir, al cambiar el tamaño del vector, los iteradores pueden quedar invalidados. Por el contrario, std::list o boost::container::stable_vector son contenedores estables que mantienen los iteradores válidos hasta la eliminación del elemento correspondiente.

¿Hay alguna manera de verificar si un contenedor dado es estable? Por ejemplo, si tengo algo así como

template<template <typename A, typename B=std::allocator<A> > class T=std::list>
class Foo
{
}

¿Es posible permitir solo contenedores estables y prohibir los inestables?

Answer 1

No creo que haya nada disponible que brinde esa información, pero podrías escribir tu propio rasgo. Sin embargo, deberá especializarlo para cada contenedor estable que se pueda usar, que tal vez no sea una opción.

#include <boost/container/vector.hpp>

#include <iostream>
#include <type_traits>
#include <list>
#include <vector>

template <template <typename...> class Container>
struct is_stable
    : std::false_type
{};

template <>
struct is_stable<std::list>
    : std::true_type
{};

template <>
struct is_stable<boost::container::stable_vector>
    : std::true_type
{};

template<template <typename...> class Container = std::list>
class Foo
{
    static_assert(is_stable<Container>::value, "Container must be stable");
};

int main()
{
    Foo<std::list> f1; // ok
    Foo<std::vector> f2; // compiler error
}

No creo que haya una manera de detectar automáticamente que un contenedor es estable, sin recurrir a la especialización manual.

Solo por diversión, intenté escribir cómo se vería el concepto / axioma de la estabilidad (los conceptos y axiomas son una extensión del lenguaje que se consideró incluir en C ++ 11 ):

concept StableGroup<typename C, typename Op>
    : Container<C>
{
    void operator()(Op, C, C::value_type);

    axiom Stability(C c, Op op, C::size_type index, C::value_type val)
    {
        if (index <= c.size())
        {
            auto it = std::advance(c.begin(), index);
            op(c, val);
            return it;
        }
        <->
        if (index <= c.size())
        {
            op(c, val);
            return std::advance(c.begin(), index);
        }
    }
}

Si cree que esto captura correctamente el requisito de que cada iterador sobre el contenedor original es equivalente al iterador correspondiente sobre el contenedor modificado. No estoy seguro de que esto sea muy útil, pero idear tales axiomas es un ejercicio interesante :)!