tamaño de arreglo (bloqueo) de std :: vector

Question

¿Hay alguna forma de arreglar el tamaño de un vector y seguir cambiando el contenido?

He intentado hacer un vector const const std::vector<int> vec(10); pero eso me impide cambiar los valores.

vec[3] = 3; da un error de compilación: asignación de ubicación de solo lectura.

también he tratado con una referencia const a un vector no const

std::vector<int> vec(10); 
const std::vector<int>& vecref(vec); 

que da el mismo error compilador.

Quiero ser capaz de fijar el tamaño del vector en la declaración o después de una etapa de inicialización. Podría usar una matriz antigua, pero quiero poder usar los algoritmos vectoriales.

Estoy usando g ++ si eso hace alguna diferencia.

Answer 1

Incrúyalo en un objeto que solo proporcione las operaciones que desea permitir.

Saludos & HTH.,

Answer 2

se puede hacer una const vector of pointers, y cambiar los objetos que apuntan. No dice que esta es la respuesta correcta, solo que es posible.

Answer 3

Eche un vistazo a boost.array, que le da una matriz de tamaño fijo con semántica vectorial (con la excepción de cualquier cosa que cambiaría el tamaño de la matriz).

Answer 4

Con C++ 0x, puede usar std :: array <>, que es como una buena matriz antigua, con el beneficio adicional de ser un contenedor STL, lo que permite muchos algoritmos std ::.

Alternativamente, es posible que desee probar boost :: array.

• boost::array
• std::array

Tenga en cuenta que también hay std::tr1::array<>.

---

edición:

Actually, one of the cases that I hadn't gone into was to grow the vector while reading configuration files and then fix the size after that - DanS

Entonces, ¿por qué no esto (illustrational):

#include <vector> 

int main() { 
    std::vector<int> foo; 

    /* ... crunch upon foo ... */ 

    // make a copy vector->vector: 
    const std::vector<int> bar (foo); 

    // make a copy any->vector 
    const std::vector<int> frob (foo.begin(), foo.end()); 
} 

Como alternativa, si necesita restablecer() la semántica, pero quiere prohibir cambiar el tamaño() y al, podría escribir un adaptador de contenedor:

template <typename T, typename Allocator = allocator<T> > 
class resettable_array { 
public: 
    // container ... 
    typedef typename std::vector<T,Allocator>::iterator iterator; 
    typedef typename std::vector<T,Allocator>::const_iterator const_iterator; 
    ... 

    iterator begin() { return vector_.begin() } 
    const_iterator begin() const { return vector_.begin(); } 
    ... 

    void push_back (T const &v) { vector_.push_back (v); } 
    ... 

    // custom 
    void reset() { ... } 

private: 
    std::vector<T,Allocator> vector_; 
}; 

Ver también:

• std::vector constructors