2012-06-21 18 views
29

¿Alguien sabe cómo definir un vector de tamaño constante?Vector de tamaño constante

Por ejemplo, en lugar de definir

std::vector<int> 

será

std::vector<10, int> 

Debe ser completamente transversal platformed. Tal vez una clase de código abierto?

Respuesta

22

El std :: vector siempre se puede crecer de forma dinámica, pero hay dos maneras en que puede asignar un tamaño inicial:

Esto asigna el tamaño inicial y llena los elementos con ceros:

std::vector<int> v(10); 
v.size(); //returns 10 

Esto asigna un tamaño inicial, pero no llena la matriz con ceros:

std::vector<int> v; 
v.reserve(10); 
v.size(); //returns 0 
+0

si era un vector de algún tipo definido por el usuario que se le dio un tamaño inicial, ¿en qué se inicializaría? – simplename

7

Uso std::array

Para una mejor legibilidad puede hacer typedef:

typedef std::array<int, 10> MyIntArray; 
+6

Por supuesto, ya que' escribiendo C++ 11, escribiríamos 'usando MyIntArray = std :: array ; '. – Tom

34

No hay manera de definir un vector de tamaño constante. Si conoce el tamaño en tiempo de compilación, puede usar el agregado std::array de C++ 11.

#include <array> 

std::array<int, 10> a; 

Si usted no tiene el correspondiente soporte para C++ 11, se puede utilizar la versión TR1:

#include <tr1/array> 

std::tr1::array<int, 10> a; 

o boost::array, como se ha sugerido en otras respuestas.

+5

Aunque tenga en cuenta que 'array' es diferente de' vector' en que los datos están contenidos dentro del objeto. Durante 10 ints, es posible que nunca note la diferencia, pero para arreglos grandes, puede notar (por ejemplo) que no tienen 'O (1)' 'swap', mientras que los vectores grandes lo hacen. –

+3

También tenga en cuenta que una matriz no tiene un concepto de 'tamaño' frente a' capacidad' como lo hace el vector. En una matriz 'size' ==' max_size'. Es decir, no puede crear una matriz de tamaño 10 (es decir, espacio para 10 elementos posibles), sino solo 5 y esperar que 'size' devuelva 5. –

7

A std::vector es un contenedor dinámico, no hay ningún mecanismo para restringir su crecimiento. Para asignar un tamaño inicial:

std::vector<int> v(10); 

C++ 11 tiene un std::array que sería más apropiado:

std::array<int, 10> my_array; 

Si el compilador no admite C++ 11 considerar el uso de boost::array:

boost::array<int, 10> my_array; 
3

Esto ---->std::vector<10, int> no es válido y causa error. Pero el nuevo estándar de C++ ha introducido una nueva clase; el std :: array. Puede declarar una matriz como esta:

std::array<int, 5> arr; // declares a new array that holds 5 ints 
std::array<int, 5> arr2(arr); // arr2 is equal to arr 
std::array<int, 5> arr3 = {1, 2, 3, 4, 5}; // arr3 holds 1, 2, 3, 4, 5 

El std::array tiene tamaño constante y apoya iterator/const_iterator/reverse_iterator/const_reverse_iterator. Puede encontrar más sobre esta clase en http://cplusplus.com/reference/stl/array/.

6

Si desea un tiempo de compilación fijo determinado tamaño (ala std::array<T, N>), pero desea poder poblar el vector con diferentes números de elementos entre 0 y N, entonces una buena opción es eastl::fixed_vector.

std :: vector:

El tamaño de un std::vector es dinámico - se destinará requerido de almacenamiento de forma dinámica, y no se puede limitar el tamaño y hacer cumplir un error.

Sin embargo, puede reserve un cierto tamaño, y luego agregar elementos de ese tamaño antes de que necesite asignar almacenamiento nuevo.

vector.size() es inicialmente 0, y se incrementa a medida que agrega elementss

std :: matriz:

El tamaño de un std::array es una constante en tiempo de compilación - se destinará almacenamiento necesaria estáticamente, y no puedes cambiar el tamaño

array.size() es siempre el tamaño de la matriz, y es igual a array.max_size()

eastl :: fixed_vector:

El tamaño de un eastl::fixed_vector pueden ser estáticos o dinámicos.

Al principio, asignará un cierto número de elementos y, si permite el crecimiento dinámico, se asignará dinámicamente si es necesario.

A los efectos que hayan solicitado inicialmente, puede desactivar el crecimiento (a través de la creación de instancias bEnableOverflow en plantilla a continuación)

fixed_vector.size() es inicialmente 0, y se incrementa a medida que agrega elementos.

template<typename T, 
     size_t nodeCount, 
     bool bEnableOverflow = true, 
     typename OverflowAllocator = 
         typename eastl::type_select<bEnableOverflow, 
                EASTLAllocatorType, 
                EASTLDummyAllocatorType>::type> 
class fixed_vector; 

ejemplo simple:

#include <iostream> 
#include <vector> 
#include <array> 
#include "EASTL/fixed_vector.h" 

int main() 
{ 
    std::vector<int> v; 
    v.reserve(10); 
    std::cout << "size=" << v.size() << " capacity=" << v.capacity() << '\n'; 

    std::array<int, 10> a; 
    std::cout << "size=" << a.size() << " capacity=" << a.max_size() << '\n'; 

    eastl::fixed_vector<int, 10, false> fv; 
    std::cout << "size=" << fv.size() << " capacity=" << fv.capacity() << '\n'; 

    return 0; 
} 

Salida:

size=0 capacity=10 
size=10 capacity=10 
size=0 capacity=10 

Tenga en cuenta que el tamaño de array es de 10, mientras que vector y fixed_vector son 0

Cuestiones relacionadas