Quelle est la façon 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::vectoret 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 une meilleure façon?

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

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, la bibliothèque 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 a des frais généraux (en gros, list_ofconstruit un std::dequesous le capot), donc pour un code critique pour les performances, vous feriez mieux de faire comme Yacoby le dit.

Si vous le pouvez, utilisez la méthode moderne C ++ [11,14,17, ...]:

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

L'ancienne façon de boucler sur un tableau de longueur variable ou d'utiliser sizeof()est vraiment terrible pour les yeux et complètement inutile en termes de surcharge mentale. Beurk.

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

Avec uniquement la prise en charge des langues, 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 :: assignation:

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

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

Je pensais juste jeter 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 et tout ce qui est requis est:

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

Mais je ne peux pas attendre C ++ 0x. Je suis bloqué car mon code doit également être compilé dans Visual Studio. Huer.

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

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

Pour l'initialisation vectorielle -

vector<int> v = {10,20,30}

peut être fait si vous avez un compilateur c ++ 11.

Sinon, vous pouvez avoir un tableau de données, puis utiliser une boucle for.

int array[] = {10,20,30}
for(unsigned int i=0; i<sizeof(array)/sizeof(array[0]); i++)
{
     v.push_back(array[i]);
}

En dehors de ceux-ci, il existe plusieurs autres façons décrites ci-dessus en utilisant du code. À mon avis, ces méthodes sont faciles à mémoriser et rapides à écrire.

La façon la plus simple de le faire est:

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

Je construis ma propre solution en utilisant va_arg. Cette solution est compatible C ++ 98.

#include <cstdarg>
#include <iostream>
#include <vector>

template <typename T>
std::vector<T> initVector (int len, ...)
{
  std::vector<T> v;
  va_list vl;
  va_start(vl, len);
  for (int i = 0; i < len; ++i)
    v.push_back(va_arg(vl, T));
  va_end(vl);
  return v;
}

int main ()
{
  std::vector<int> v = initVector<int> (7,702,422,631,834,892,104,772);
  for (std::vector<int>::const_iterator it = v.begin() ; it != v.end(); ++it)
    std::cout << *it << std::endl;
  return 0;
}

Démo

Si votre compilateur prend en charge les macros Variadic (ce qui est vrai pour la plupart des compilateurs modernes), vous pouvez utiliser la macro suivante pour transformer l'initialisation vectorielle en une ligne:

#define INIT_VECTOR(type, name, ...) \
static const type name##_a[] = __VA_ARGS__; \
vector<type> name(name##_a, name##_a + sizeof(name##_a) / sizeof(*name##_a))

Avec cette macro, vous pouvez définir un vecteur initialisé avec un code comme celui-ci:

INIT_VECTOR(int, my_vector, {1, 2, 3, 4});

Cela créerait un nouveau vecteur d'entiers nommé my_vector avec les éléments 1, 2, 3, 4.

Si vous ne souhaitez pas utiliser boost, mais souhaitez profiter de la syntaxe comme

std::vector<int> v;
v+=1,2,3,4,5;

il suffit d'inclure ce morceau de code

template <class T> class vector_inserter{
public:
    std::vector<T>& v;
    vector_inserter(std::vector<T>& v):v(v){}
    vector_inserter& operator,(const T& val){v.push_back(val);return *this;}
};
template <class T> vector_inserter<T> operator+=(std::vector<T>& v,const T& x){
    return vector_inserter<T>(v),x;
}

En C ++ 11:

static const int a[] = {10, 20, 30};
vector<int> vec (begin(a), end(a));

vous pouvez le faire en utilisant boost :: assign.

vector<int> values;  
values += 1,2,3,4,5,6,7,8,9;

détail ici

Une question en double plus récente a cette réponse par Viktor Sehr . Pour moi, il est compact, visuellement attrayant (on dirait que vous `` enfoncez '' les valeurs dans), ne nécessite pas c ++ 11 ou un module tiers, et évite d'utiliser une variable supplémentaire (écrite). Voici comment je l'utilise avec quelques modifications. Je peux passer à l'extension de la fonction de vector et / ou va_arg dans le futur intead.

// Based on answer by "Viktor Sehr" on Stack Overflow
// https://stackoverflow.com/a/8907356
//
template <typename T>
class mkvec {
public:
    typedef mkvec<T> my_type;
    my_type& operator<< (const T& val) {
        data_.push_back(val);
        return *this;
    }
    my_type& operator<< (const std::vector<T>& inVector) {
        this->data_.reserve(this->data_.size() + inVector.size());
        this->data_.insert(this->data_.end(), inVector.begin(), inVector.end());
        return *this;
    }
    operator std::vector<T>() const {
        return data_;
    }
private:
    std::vector<T> data_;
};

std::vector<int32_t>    vec1;
std::vector<int32_t>    vec2;

vec1 = mkvec<int32_t>() << 5 << 8 << 19 << 79;  
// vec1 = (5,8,19,79)
vec2 = mkvec<int32_t>() << 1 << 2 << 3 << vec1 << 10 << 11 << 12;  
// vec2 = (1,2,3,5,8,19,79,10,11,12)

Les méthodes ci-dessous peuvent être utilisées pour initialiser le vecteur en c ++.

1. int arr[] = {1, 3, 5, 6}; vector<int> v(arr, arr + sizeof(arr)/sizeof(arr[0]));

2. vector<int>v; v.push_back(1); v.push_back(2); v.push_back(3); etc

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

Le troisième est autorisé uniquement en C ++ 11.

Il y a beaucoup de bonnes réponses ici, mais comme je suis arrivé indépendamment avant de lire ceci, j'ai pensé que je jetterais le mien ici de toute façon ...

Voici une méthode que j'utilise pour cela qui fonctionnera universellement sur les compilateurs et les plates-formes:

Créez une structure ou une classe en tant que conteneur pour votre collection d'objets. Définissez une fonction de surcharge d'opérateur pour <<.

class MyObject;

struct MyObjectList
{
    std::list<MyObject> objects;
    MyObjectList& operator<<( const MyObject o )
    { 
        objects.push_back( o );
        return *this; 
    }
};

Vous pouvez créer des fonctions qui prennent votre structure en paramètre, par exemple:

someFunc( MyObjectList &objects );

Ensuite, vous pouvez appeler cette fonction, comme ceci:

someFunc( MyObjectList() << MyObject(1) <<  MyObject(2) <<  MyObject(3) );

De cette façon, vous pouvez créer et transmettre une collection d'objets de taille dynamique à une fonction en une seule ligne épurée!

Si vous voulez quelque chose sur le même ordre général que Boost :: assign sans créer de dépendance sur Boost, ce qui suit est au moins vaguement similaire:

template<class T>
class make_vector {
    std::vector<T> data;
public:
    make_vector(T const &val) { 
        data.push_back(val);
    }

    make_vector<T> &operator,(T const &t) {
        data.push_back(t);
        return *this;
    }

    operator std::vector<T>() { return data; }
};

template<class T> 
make_vector<T> makeVect(T const &t) { 
    return make_vector<T>(t);
}

Bien que je souhaite que la syntaxe pour l'utiliser soit plus propre, elle n'est toujours pas particulièrement horrible:

std::vector<int> x = (makeVect(1), 2, 3, 4);

typedef std::vector<int> arr;

arr a {10, 20, 30};       // This would be how you initialize while defining

Pour compiler l'utilisation:

clang++ -std=c++11 -stdlib=libc++  <filename.cpp>

// Before C++11
// I used following methods:

// 1.
int A[] = {10, 20, 30};                              // original array A

unsigned sizeOfA = sizeof(A)/sizeof(A[0]);           // calculate the number of elements

                                                     // declare vector vArrayA,
std::vector<int> vArrayA(sizeOfA);                   // make room for all
                                                     // array A integers
                                                     // and initialize them to 0 

for(unsigned i=0; i<sizeOfA; i++)
    vArrayA[i] = A[i];                               // initialize vector vArrayA


//2.
int B[] = {40, 50, 60, 70};                          // original array B

std::vector<int> vArrayB;                            // declare vector vArrayB
for (unsigned i=0; i<sizeof(B)/sizeof(B[0]); i++)
    vArrayB.push_back(B[i]);                         // initialize vArrayB

//3.
int C[] = {1, 2, 3, 4};                              // original array C

std::vector<int> vArrayC;                            // create an empty vector vArrayC
vArrayC.resize(sizeof(C)/sizeof(C[0]));              // enlarging the number of 
                                                     // contained elements
for (unsigned i=0; i<sizeof(C)/sizeof(C[0]); i++)
     vArrayC.at(i) = C[i];                           // initialize vArrayC


// A Note:
// Above methods will work well for complex arrays
// with structures as its elements.

Si le tableau est:

int arr[] = {1, 2, 3};
int len = (sizeof(arr)/sizeof(arr[0])); // finding length of array
vector < int > v;
std:: v.assign(arr, arr+len); // assigning elements from array to vector 

Il est assez pratique de créer un vecteur en ligne sans définir de variable lors de l'écriture du test, par exemple:

assert(MyFunction() == std::vector<int>{1, 3, 4}); // <- this.

En relation, vous pouvez utiliser ce qui suit si vous voulez avoir un vecteur complètement prêt à aller dans une déclaration rapide (par exemple, passer immédiatement à une autre fonction):

#define VECTOR(first,...) \
   ([](){ \
   static const decltype(first) arr[] = { first,__VA_ARGS__ }; \
   std::vector<decltype(first)> ret(arr, arr + sizeof(arr) / sizeof(*arr)); \
   return ret;})()

exemple de fonction

template<typename T>
void test(std::vector<T>& values)
{
    for(T value : values)
        std::cout<<value<<std::endl;
}

exemple d'utilisation

test(VECTOR(1.2f,2,3,4,5,6));

mais faites attention au decltype, assurez-vous que la première valeur correspond clairement à ce que vous voulez.

Il existe différentes façons de coder en dur un vecteur, je vais partager quelques façons:

1. Initialisation en poussant les valeurs une par une

// Create an empty vector 
    vector<int> vect;  

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

2. Initialisation comme des tableaux

vector<int> vect{ 10, 20, 30 };

3. Initialisation à partir d'un tableau

    int arr[] = { 10, 20, 30 }; 
    int n = sizeof(arr) / sizeof(arr[0]); 

    vector<int> vect(arr, arr + n); 

4. Initialisation à partir d'un autre vecteur

    vector<int> vect1{ 10, 20, 30 }; 

    vector<int> vect2(vect1.begin(), vect1.end()); 

"Comment créer un vecteur STL et l'initialiser comme ci-dessus? Quelle est la meilleure façon de le faire avec un effort de frappe minimal?"

La façon la plus simple d'initialiser un vecteur lorsque vous avez initialisé votre tableau intégré est d'utiliser une liste d'initialisation qui a été introduite en C ++ 11 .

// Initializing a vector that holds 2 elements of type int.
Initializing:
std::vector<int> ivec = {10, 20};


// The push_back function is more of a form of assignment with the exception of course
//that it doesn't obliterate the value of the object it's being called on.
Assigning
ivec.push_back(30);

ivec a 3 éléments après l'exécution de l'attribution (instruction étiquetée).

B. Stroustrup décrit une belle façon de chaîner des opérations dans 16.2.10 Selfreference à la page 464 dans l'édition C ++ 11 du Prog. Lang. où une fonction renvoie une référence, ici modifiée en vecteur. De cette façon, vous pouvez enchaîner v.pb(1).pb(2).pb(3);mais peut être trop de travail pour de si petits gains.

#include <iostream>
#include <vector>

template<typename T>
class chain
{
private:
    std::vector<T> _v;
public:
    chain& pb(T a) {
        _v.push_back(a);
        return *this;
    };
    std::vector<T> get() { return _v; };
};

using namespace std;

int main(int argc, char const *argv[])
{
    chain<int> v{};

    v.pb(1).pb(2).pb(3);

    for (auto& i : v.get()) {
        cout << i << endl;
    }

    return 0;
}

1
2
3

La manière la plus simple et la plus ergonomique (avec C ++ 11 ou version ultérieure):

auto my_ints = {1,2,3};

Au cas où vous voudriez l'avoir dans votre propre classe:

#include <initializer_list>
Vector<Type>::Vector(std::initializer_list<Type> init_list) : _size(init_list.size()),
_capacity(_size),
_data(new Type[_size])
{
    int idx = 0;
    for (auto it = init_list.begin(); it != init_list.end(); ++it)
        _data[idx++] = *it;
}