Quel est le moyen le plus simple d'initialiser un std::vector avec des éléments codés en dur ?

Question

Je peux créer un tableau et l'initialiser comme ceci :

int a[] = {10, 20, 30};

Comment créer un std::vector et l'initialiser de manière aussi élégante ?

Le meilleur moyen que je connaisse est :

std::vector<int> ints;

ints.push_back(10);
ints.push_back(20);
ints.push_back(30);

Y a-t-il un meilleur moyen ?

Answer 1

Si votre compilateur supporte C++11, vous pouvez simplement faire :

std::vector<int> v = {1, 2, 3, 4};

Ceci est disponible dans GCC à partir de la version 4.4 . Malheureusement, VC++ 2010 semble être à la traîne à cet égard.

Alternativement, le Boost.Assign utilise la magie non-macro pour permettre ce qui suit :

#include <boost/assign/list_of.hpp>
...
std::vector<int> v = boost::assign::list_of(1)(2)(3)(4);

Ou :

#include <boost/assign/std/vector.hpp>
using namespace boost::assign;
...
std::vector<int> v;
v += 1, 2, 3, 4;

Mais gardez à l'esprit que cela entraîne des frais généraux (essentiellement, list_of construit un std::deque sous le capot), donc pour du code critique en termes de performances, il vaut mieux faire comme Yacoby.

Answer 2

Une méthode serait d'utiliser le tableau pour initialiser le vecteur

static const int arr[] = {16,2,77,29};
vector<int> vec (arr, arr + sizeof(arr) / sizeof(arr[0]) );

Answer 3

En C++0x, vous pourrez le faire de la même manière qu'avec un tableau, mais pas dans la norme actuelle.

Avec le seul support linguistique que vous pouvez utiliser :

int tmp[] = { 10, 20, 30 };
std::vector<int> v( tmp, tmp+3 ); // use some utility to avoid hardcoding the size here

Si vous pouvez ajouter d'autres bibliothèques, vous pouvez essayer boost::assignment :

vector<int> v = list_of(10)(20)(30);

Pour éviter de coder en dur la taille d'un tableau :

// option 1, typesafe, not a compile time constant
template <typename T, std::size_t N>
inline std::size_t size_of_array( T (&)[N] ) {
   return N;
}
// option 2, not typesafe, compile time constant
#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))

// option 3, typesafe, compile time constant
template <typename T, std::size_t N>
char (&sizeof_array( T(&)[N] ))[N];    // declared, undefined
#define ARRAY_SIZE(x) sizeof(sizeof_array(x))

Answer 4

En C++11 :

#include <vector>
using std::vector;
...
vector<int> vec1 { 10, 20, 30 };
// or
vector<int> vec2 = { 10, 20, 30 };

Utilisation de Boost list_of :

#include <vector>
#include <boost/assign/list_of.hpp>
using std::vector;
...
vector<int> vec = boost::assign::list_of(10)(20)(30);

Utilisation de l'assignation Boost :

#include <vector>
#include <boost/assign/std/vector.hpp>
using std::vector;
...
vector<int> vec;
vec += 10, 20, 30;

Conventionnel STL :

#include <vector>
using std::vector;
...
static const int arr[] = {10,20,30};
vector<int> vec (arr, arr + sizeof(arr) / sizeof(arr[0]) );

STL conventionnel avec macros génériques :

#include <vector>
#define ARRAY_SIZE(ar) (sizeof(ar) / sizeof(ar[0])
#define ARRAY_END(ar) (ar + ARRAY_SIZE(ar))
using std::vector;
...
static const int arr[] = {10,20,30};
vector<int> vec (arr, ARRAY_END(arr));

STL conventionnel avec une macro d'initialisation de vecteur :

#include <vector>
#define INIT_FROM_ARRAY(ar) (ar, ar + sizeof(ar) / sizeof(ar[0])
using std::vector;
...
static const int arr[] = {10,20,30};
vector<int> vec INIT_FROM_ARRAY(arr);

Answer 5

J'ai tendance à déclarer

template< typename T, size_t N >
std::vector<T> makeVector( const T (&data)[N] )
{
    return std::vector<T>(data, data+N);
}

dans un en-tête d'utilitaire quelque part et ensuite tout ce qui est nécessaire est :

const double values[] = { 2.0, 1.0, 42.0, -7 };
std::vector<double> array = makeVector(values);