Contenedor inmutable con contenido mutable

Question

La historia comienza con algo que creí muy simple:

Necesito diseñar una clase que use algunos contenedores STL. Necesito dar acceso a los usuarios de la clase a una versión inmutable de esos contenedores. No quiero que los usuarios puedan cambiar el contenedor (no pueden push_back() en una lista, por ejemplo), pero quiero que los usuarios puedan cambiar los objetos contenidos (obtenga un elemento con back() y modifíquelo) :

class Foo 
{ 
    public: 

    // [...] 

    ImmutableListWithMutableElementsType getImmutableListWithMutableElements(); 

    // [...] 
}; 

// [...] 

myList = foo.getImmutableListWithMutableElements(); 
myElement = myList.back(); 
myElement.change(42); // OK 

// [...] 

// myList.push_back(myOtherElement); // Not possible 

a primera vista, parece que un contenedor const va a hacer. Pero, por supuesto, sólo se puede utilizar un iterador const en un recipiente const y no se puede cambiar el contenido.

en una segunda mirada, cosas como especializada de contenedores o iterador vienen a la mente. Probablemente termine con eso.

Entonces, mi pensamiento es "Alguien tiene que haber hecho ya!" o "¡Debe existir una solución elegante y genérica!" y estoy aquí haciendo mi primera pregunta sobre SO:

¿Cómo se diseña/transformar un contenedor estándar en un recipiente con el contenido inmutable mutable?

estoy trabajando en ello, pero me siento como si alguien le acaba de decir "Hey, yo que cada vez, es fácil, mira!", Por lo que pido ...

Gracias por cualquier insinuación, sugerencias o maravillosas formas genéricas para hacer eso :)

---

EDIT:

Después de algunos experimentos, que terminó con contenedores estándar que manejan algunos punteros inteligentes decoradas específicamente. Está cerca de la respuesta de Nikolai.

La idea de un contenedor de elementos inmutables mutables no es un concepto matar, ver las notas interesantes en respuesta Oli.

La idea de un iterador específica es correcto, por supuesto, pero no parece práctico, ya que necesito para adaptarse a cualquier tipo de contenedor.

Gracias a todos por su ayuda.

Answer 1

La opción más sencilla sería probablemente un contenedor STL estándar de punteros, ya que const -ness no se propaga a los objetos reales. Un problema con esto es que STL no limpia la memoria de montón que asignó. Para eso echa un vistazo a Boost Pointer Container Library o smart pointers.

Answer 2

En lugar de proporcionarle al usuario todo el contenedor, ¿podría simplemente proporcionarles iteradores no const para comenzar y finalizar? Esa es la forma de STL.

Answer 3

La solución dolorosa:

/* YOU HAVE NOT SEEN THIS */ 
struct mutable_int { 
    mutable_int(int v = 0) : v(v) { } 
    operator int(void) const { return v; } 
    mutable_int const &operator=(int nv) const { v = nv; return *this; } 

    mutable int v; 
}; 

Discúlpame mientras tengo que castigarme a mí mismo para expiar mis pecados.

Answer 4

Necesita un iterador de estructura de datos personalizado, un contenedor alrededor de su lista privada.

template<typename T> 
class inmutable_list_it { 
public: 
    inmutable_list_it(std::list<T>* real_list) : real_list_(real_list) {} 

    T first() { return *(real_list_->begin()); } 

    // Reset Iteration 
    void reset() { it_ = real_list_->begin(); } 

    // Returns current item 
    T current() { return *it_; } 

    // Returns true if the iterator has a next element. 
    bool hasNext(); 

private: 
    std::list<T>* real_list_; 
    std::list<T>::iterator it_; 
};