Come verificare se un contenitore è stabile

Question

std::vector è un contenitore instabile, ovvero ridimensionando il vettore, gli iteratori potrebbero essere invalidati. Al contrario, std::list o boost::container::stable_vector sono contenitori stabili che mantengono validi gli iteratori fino alla rimozione dell'elemento corrispondente.

C'è un modo per verificare se un determinato contenitore è stabile? Per esempio, se ho qualcosa come

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

È possibile consentire solo per contenitori stabili e vietare quelli instabili?

Answer 1

Non penso che ci sia qualcosa di disponibile che fornisca tali informazioni, ma potresti scrivere il tuo tratto personale. Tuttavia, è necessario specializzarlo per ogni contenitore stabile che può essere utilizzato, che forse non è un'opzione.

#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 
} 

Non penso ci sia un modo per rilevare automaticamente che un container è stabile, senza ricorrere alla specializzazione manuale.

---

Solo per divertimento, ho provato a scrivere ciò che il concetto/assioma per la stabilità sarebbe simile (concepts e axioms sono un'estensione al linguaggio che erano considered for inclusion in 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); 
     } 
    } 
} 

Se pensi questo correttamente cattura il requisito che ogni iteratore sul contenitore originale sia equivalente all'iteratore corrispondente sul contenitore modificato. Non è sicuro che sia molto utile, ma inventare questi assiomi è un esercizio interessante :)!