Question Quelle est la manière la plus simple d'initialiser un vecteur std :: avec des éléments codés en dur?


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

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

Comment puis-je créer un std::vector et l'initialiser de la même manière élégante?

La meilleure façon 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?


507
2018-02-10 10:55


origine


Réponses:


Une méthode consisterait à 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]) );

482
2018-02-10 11:00



Si votre compilateur prend en charge 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 La bibliothèque utilise la magie non-macro pour autoriser 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 a des frais généraux (essentiellement, list_of construit un std::deque sous le capot) donc pour le code critique de performance, vous feriez mieux de faire comme le dit Yacoby.


512
2018-02-10 11:01



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

Avec seulement le support de la langue, 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 le codage en dur de 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))

70
2018-02-10 11:00



Je pensais juste jeter dans mes 0,02 $. J'ai tendance à déclarer ceci:

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, puis tout ce qui est nécessaire est:

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

Mais je ne peux pas attendre pour C ++ 0x. Je suis bloqué parce que mon code doit également compiler dans Visual Studio. Huer.


48
2018-04-03 04:15



En C ++ 11:

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

En utilisant boost list_of:

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

En utilisant boost assign:

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

STL conventionnel:

#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 vectorielle:

#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);

46
2017-10-07 21:30



Avant C ++ 11:

Méthode 1 =>

vector<int> v(arr, arr + sizeof(arr)/sizeof(arr[0]));
vector<int>v;

Méthode 2 =>

 v.push_back(SomeValue);

C ++ 11 ci-dessous est également possible

vector<int>v = {1, 3, 5, 7};

31
2017-08-03 09:13



Commençant par:

int a[] = {10, 20, 30}; //i'm assuming a is just a placeholder

Si vous n'avez pas de compilateur C ++ 11 et que vous ne voulez pas utiliser boost:

const int a[] = {10, 20, 30};
const std::vector<int> ints(a,a+sizeof(a)/sizeof(int)); //make it const if you can

Si vous n'avez pas de compilateur C ++ 11 et pouvez utiliser boost:

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

Si vous avez un compilateur C ++ 11:

const std::vector<int> ints = {10,20,30};

25
2017-12-12 00:01