Qual è il modo più semplice per inizializzare uno std :: vector con elementi hardcoded?

Posso creare un array e inizializzarlo in questo modo:

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

Come posso creare std::vectore inizializzare allo stesso modo elegante?

Il modo migliore che conosco è:

std::vector<int> ints;

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

Esiste un modo migliore?

Un metodo sarebbe quello di utilizzare l'array per inizializzare il vettore

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

Se il tuo compilatore supporta C ++ 11, puoi semplicemente fare:

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

Questo è disponibile in GCC a partire dalla versione 4.4 . Sfortunatamente, VC ++ 2010 sembra essere in ritardo in questo senso.

In alternativa, la libreria Boost.Assign utilizza la magia non macro per consentire quanto segue:

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

O:

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

Ma tieni presente che questo ha un certo sovraccarico (fondamentalmente, list_ofcostruisce un std::dequesottotetto), quindi per il codice critico per le prestazioni ti conviene fare come dice Yacoby.

Se puoi, usa il moderno modo C ++ [11,14,17, ...]:

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

Il vecchio modo di eseguire il loop su un array a lunghezza variabile o di utilizzarlo sizeof()è veramente terribile agli occhi e completamente inutile in termini di sovraccarico mentale. Che schifo.

In C ++ 0x sarai in grado di farlo come hai fatto con un array, ma non nello standard attuale.

Con solo il supporto linguistico è possibile utilizzare:

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

Se puoi aggiungere altre librerie puoi provare boost :: assegnazione:

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

Per evitare l'hardcoding della dimensione di un array:

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

In C ++ 11:

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

Utilizzando boost list_of:

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

Utilizzando l'assegnazione boost:

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

STL convenzionale:

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

STL convenzionale con macro generiche:

#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 convenzionale con una macro di inizializzatore vettoriale:

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

Ho pensato di lanciare $ 0,02. Tendo a dichiararlo:

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

in un'intestazione di utilità da qualche parte e quindi tutto ciò che serve è:

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

Ma non posso aspettare C ++ 0x. Sono bloccato perché il mio codice deve anche essere compilato in Visual Studio. Boo.

Prima di C ++ 11:

Metodo 1 =>

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

Metodo 2 =>

 v.push_back(SomeValue);

C ++ 11 in poi è anche possibile

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

Iniziare con:

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

Se non si dispone di un compilatore C ++ 11 e non si desidera utilizzare boost:

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

Se non hai un compilatore C ++ 11 e puoi usare boost:

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

Se si dispone di un compilatore C ++ 11:

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

Per l'inizializzazione vettoriale -

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

può essere fatto se si dispone del compilatore c ++ 11.

Altrimenti, puoi avere un array di dati e quindi utilizzare un ciclo for.

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

Oltre a questi, ci sono vari altri modi descritti sopra usando del codice. Secondo me, questi modi sono facili da ricordare e veloci da scrivere.

Il modo più semplice per farlo è:

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

Costruisco la mia soluzione usando va_arg. Questa soluzione è conforme a 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;
}

dimostrazione

Se il tuo compilatore supporta le macro Variadic (il che è vero per la maggior parte dei compilatori moderni), puoi utilizzare la seguente macro per trasformare l'inizializzazione vettoriale in una riga:

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

Con questa macro, è possibile definire un vettore inizializzato con codice come questo:

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

Ciò creerebbe un nuovo vettore di ints chiamato my_vector con gli elementi 1, 2, 3, 4.

Se non vuoi usare boost, ma vuoi goderti la sintassi come

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

includi solo questo pezzo di codice

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

In C ++ 11:

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

puoi farlo usando boost :: assegnare.

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

dettagli qui

Una domanda duplicata più recente ha questa risposta di Viktor Sehr . Per me è compatto, visivamente accattivante (sembra che tu stia inserendo i valori in), non richiede c ++ 11 o un modulo di terze parti ed evita di usare una variabile (scritta) aggiuntiva. Di seguito è come lo sto usando con alcune modifiche. Potrei passare ad estendere la funzione di vettore e / o va_arg in futuro.

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

I metodi seguenti possono essere utilizzati per inizializzare il vettore in 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); e così via

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

Il terzo è consentito solo da C ++ 11 in poi.

Ci sono molte buone risposte qui, ma dal momento che sono arrivato autonomamente da solo prima di leggere questo, ho pensato di gettare il mio qui comunque ...

Ecco un metodo che sto usando per questo che funzionerà universalmente su compilatori e piattaforme:

Crea una struttura o classe come contenitore per la tua raccolta di oggetti. Definire una funzione di sovraccarico dell'operatore per <<.

class MyObject;

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

Puoi creare funzioni che prendono la tua struct come parametro, ad es .:

someFunc( MyObjectList &objects );

Quindi, puoi chiamare quella funzione, in questo modo:

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

In questo modo, puoi costruire e passare una raccolta di oggetti di dimensioni dinamiche a una funzione in un'unica linea pulita!

Se si desidera qualcosa sullo stesso ordine generale di Boost :: assegnare senza creare una dipendenza da Boost, quanto segue è almeno vagamente simile:

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

Mentre vorrei che la sintassi per usarla fosse più pulita, non è ancora particolarmente terribile:

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

Per compilare utilizzare:

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.

Se l'array è:

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 

È abbastanza conveniente creare un vettore in linea senza definire la variabile durante la scrittura del test, ad esempio:

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

Correlato, è possibile utilizzare quanto segue se si desidera avere un vettore completamente pronto per andare in una dichiarazione rapida (ad esempio passare immediatamente a un'altra funzione):

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

funzione di esempio

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

esempio di utilizzo

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

anche se fai attenzione al decltype, assicurati che il primo valore sia chiaramente quello che vuoi.

Esistono vari modi per codificare un vettore, condividerò alcuni modi:

1. Inizializzazione spingendo i valori uno per uno

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

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

2. Inizializzazione come array

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

3. Inizializzazione da un array

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

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

4. Inizializzazione da un altro vettore

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

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

"Come posso creare un vettore STL e inizializzarlo come sopra? Qual è il modo migliore per farlo con il minimo sforzo di digitazione?"

Il modo più semplice per inizializzare un vettore dopo aver inizializzato l'array incorporato è utilizzare un elenco di inizializzatori introdotto in 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 ha 3 elementi di dimensione dopo l'esecuzione di Assigning (labeled statement).

B. Stroustrup descrive un modo piacevole di concatenare le operazioni in 16.2.10 Auto-riferimento a pagina 464 nell'edizione C ++ 11 del Prog. Lang. dove una funzione restituisce un riferimento, qui modificato in un vettore. In questo modo puoi concatenare come v.pb(1).pb(2).pb(3);ma potrebbe essere troppo lavoro per guadagni così piccoli.

#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

Il modo più semplice ed ergonomico (con C ++ 11 o successivo):

auto my_ints = {1,2,3};

Se vuoi averlo nella tua 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;
}