web-dev-qa-db-fra.com

Vecteur de taille constante

Quelqu'un sait-il comment définir un vecteur de taille constante?

Par exemple, au lieu de définir

std::vector<int>

ce sera

std::vector<10, int>

Il devrait être complètement multiplateforme. Peut-être une classe open source?

c++stlvector
40
Iron-Eagle

Le vecteur std :: peut toujours croître dynamiquement, mais il existe deux façons d'allouer une taille initiale:

Cela alloue la taille initiale et remplit les éléments avec des zéros:

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

Cela alloue une taille initiale mais ne remplit pas le tableau avec des zéros:

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

Il n'y a aucun moyen de définir un vecteur de taille constante. Si vous connaissez la taille au moment de la compilation, vous pouvez utiliser l'agrégat std :: array de C++ 11.

#include <array>

std::array<int, 10> a;

Si vous ne disposez pas de la prise en charge C++ 11 appropriée, vous pouvez utiliser la version TR1:

#include <tr1/array>

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

ou boost :: array , comme cela a été suggéré dans d'autres réponses.

47
juanchopanza

Utilisez std :: arrayc ++ 11

Pour une meilleure lisibilité, vous pouvez faire typedef:

typedef std::array<int, 10> MyIntArray;
12
Andrew

Si vous voulez une taille spécifiée au moment de la compilation fixe (ala std::array<T, N>), Mais vous voulez pouvoir remplir le vecteur avec un nombre variable d'éléments entre 0 Et N, alors une bonne option est eastl::fixed_vector .

std :: vector:

La taille d'un std::vector Est dynamique - il allouera dynamiquement le stockage requis, et vous ne pouvez pas limiter la taille et appliquer une erreur.

Vous pouvez toutefois reserve une certaine taille, puis ajouter des éléments à cette taille avant qu'il n'ait besoin d'allouer de nouveau stockage.

vector.size() est initialement 0, et augmente à mesure que vous ajoutez des éléments

std :: array:

La taille d'un std::array Est une constante de temps de compilation - elle allouera statiquement le stockage requis, et vous ne pouvez pas modifier la taille.

array.size() est toujours la taille du tableau, et est égal à array.max_size()

eastl :: fixed_vector:

La taille d'un eastl::fixed_vector Peut être statique ou dynamique.

Il allouera initialement un certain nombre d'éléments, puis si vous autorisez une croissance dynamique, il allouera dynamiquement si nécessaire.

Aux fins que vous aviez initialement demandées, vous pouvez désactiver la croissance (via bEnableOverflow dans l'instanciation du modèle ci-dessous)

fixed_vector.size() est initialement 0 et augmente à mesure que vous ajoutez des éléments.

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

Exemple 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;
}

Sortie:

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

Notez que la taille de array est 10, tandis que vector et fixed_vector Sont 0

11
Steve Lorimer

UNE std::vector est un conteneur dynamique, il n'y a aucun mécanisme pour limiter sa croissance. Pour allouer une taille initiale:

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

C++ 11 a un std::array qui serait plus approprié:

std::array<int, 10> my_array;

Si votre compilateur ne prend pas en charge C++ 11, envisagez d'utiliser boost::array :

boost::array<int, 10> my_array;
9
hmjd

C'est une vieille question mais si quelqu'un a juste besoin conteneur indexé de taille constante avec une taille définie au moment de l'exécution, j'aime utiliser unique_ptr :

// c++14
auto constantContainer = std::make_unique<YourType []> ( size );

// c++11
std::unique_ptr<YourType[]> constantContainer {new YourType[ size ]};


// Access
constantContainer[ i ]
4
Pari

Ce ----> std::vector<10, int> n'est pas valide et provoque une erreur. Mais la nouvelle norme C++ a introduit une nouvelle classe; le tableau std ::. Vous pouvez déclarer un tableau comme celui-ci:

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

Le std::array a une taille constante et prend en charge iterator/const_iterator/reverse_iterator/const_reverse_iterator. Vous pouvez trouver plus d'informations sur cette classe sur http://cplusplus.com/reference/stl/array/ .

2
Rontogiannis Aristofanis