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


612

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?


1
se non si intende modificare la dimensione degli ints dopo l'inizializzazione, considerare l'utilizzo dell'array tr1.
zr.

@zr, mi hai incuriosito ... se avessi bisogno di dimensioni fisse, non potrei usare da solo le vecchie matrici? Guardando l'array tr1 in questo momento ...
Agnel Kurian,

2
tr1::arrayè utile perché le normali matrici non forniscono l'interfaccia dei contenitori STL
Manuel,

Modificato il titolo per renderlo esplicitamente una domanda C ++ 03. Sembrava più semplice che esaminare e correggere tutte le risposte per dare un senso al nuovo standard C ++.
TED

Risposte:


548

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

7
@Agnel Funzionerà bene senza statico const, tuttavia entrambi lo rendono più esplicito su come dovrebbe essere usato e consentono al compilatore di effettuare ulteriori ottimizzazioni.
Yacoby,

68
Non ho minimizzato questo, ma ero tentato. Soprattutto perché questo non ti fa risparmiare quasi nulla solo usando l'array inizializzato in primo luogo. Tuttavia, è davvero colpa di C ++, non tua.
TED

2
Puoi spiegare perché stai usando quei parametri quando definisci il vettore vec.
DomX23,

13
sizeof (array) è una delle poche eccezioni che consente di ottenere la dimensione totale degli elementi dell'array e NON la dimensione del puntatore arr. Quindi fondamentalmente sta usando il vettore (pointer_to_first_element, pointer_to_first_element + size_in_bytes_of_the_whole_array / size_of_one_element) ovvero: vector (pointer_to_first_element, pointer_after_final_element). Il tipo è già indicato con <int>, quindi il vettore sa quanto è un elemento. Ricorda che gli iteratori possono essere trattati come puntatori, quindi sostanzialmente stai usando il costruttore vettoriale (inizio iteratore, fine iteratore)
Johnny Pauling,

11
@TED: a volte è necessario modificare il vettore risultante. Ad esempio, potrebbe essere necessario disporre sempre di alcuni parametri predefiniti e talvolta aggiungerne alcuni personalizzati.
DarkWanderer,

642

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.


Dato che i vettori sono auto-dimensionanti, sarebbe opportuno inizializzarlo come vuoto? Come nel costruttore this->vect = {};:?
Azurespot

3
@Azurespot Puoi solo inizializzarlo e sarà vuoto:std::vector<T> vector;
Luca

2
Nel caso in cui qualcuno possa essere curioso std::vector<int> v = {1, 2, 3, 4};, i vettore initializer list constructorverranno chiamati per questo tipo di inizializzazione, il suo documento può essere trovato nella C++ 11sezione .
simomo

103

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.


2
In tutta onestà, questa era originariamente una domanda C ++ 03, ma spero che le persone / aziende adottino i nuovi standard. C ++ richiede ancora un'implementazione di array a lunghezza variabile (VLA) nella libreria standard simile a quella disponibile in Eigen e Boost.
Adam Erickson,

Sfortunatamente, questo approccio è problematico in alcuni casi, ad esempio open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1467 . Che schifo.
Corse della leggerezza in orbita,

Se "inizializzazione elenco di un aggregato da un oggetto dello stesso tipo" fa per te, probabilmente ci sono problemi più grandi nella tua base di codice ... Non riesco a pensare a nessuna applicazione in cui giustificherebbe i problemi di debug.
Adam Erickson,

77

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

Ovviamente non ho effettuato il downvote ma ho comunque una domanda: quando la dimensione di un array non è una costante di tempo di compilazione? Vale a dire, in quali casi useresti la prima soluzione nel tuo secondo frammento rispetto alla terza?
Manuel,

4
@Manuel, la dimensione dell'array fa parte del tipo e come tale è una costante di tempo di compilazione. Ora, l'opzione 1 usa quella costante di compilazione 'N' come valore di ritorno per una funzione. Il ritorno di una funzione non è un tempo di compilazione, ma un valore di runtime, anche se probabilmente verrà incluso come valore costante nel luogo di chiamata. La differenza è che non puoi fare:, int another[size_of_array(array)]mentre puoi farlo int another[ARRAY_SIZE(array)].
David Rodríguez - dribeas,

1
Nell'opzione 3: non capisco cosa intendi con "dichiarato, indefinito"? Quindi la variabile non occuperà memoria aggiuntiva?
To1ne

1
@ To1ne che in realtà è una dichiarazione di funzione, non una variabile. Il motivo o la sua definizione è che in realtà non vogliamo la funzione per nient'altro che l' sizeofespressione che non ha bisogno di una definizione. Mentre puoi effettivamente fornire una definizione, per farlo nel modo giusto richiederebbe l'allocazione statica di un array e restituire un riferimento ad esso, e la domanda successiva sarebbe cosa avrebbe senso come valori per l'array? (Si noti inoltre che ciò significa una matrice per combinazione di tipo / dimensione delle istanze della funzione!) Poiché non è un uso ragionevole per essa, preferirei evitarlo.
David Rodríguez - dribeas,

1
@mhd: non è possibile costruire un array vuoto nella lingua. 'int arr [0] = {};' non è un codice C ++ valido. Ma hai ragione che se vuoi inizializzare un vettore vuoto e un vettore non vuoto dovrai usare costrutti diversi. Dal C ++ 11 questo non è un problema in quanto puoi usare il costruttore della lista di inizializzatori
David Rodríguez - dribeas,

61

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

2
C ++ 11 supporta anche std::begine std::endper array, quindi un vettore può anche essere inizializzato come static const int arr[] = {10,20,30}; vector<int> vec(begin(arr), end(arr));.
Jaege,

54

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.


1
Questa tecnica può anche essere utilizzata per sovraccaricare una funzione per accettare un array con dimensioni digitate.
Andres Riofrio,

4
Puoi spiegare la const T (&data)[N]parte? Come viene dedotta la dimensione dell'array nella chiamata makeVector(values)?
Patryk,

36

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

28

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

22

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.



16

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


14

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.


13

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

1
Non sono stato in grado di capire come usare questo codice, ma sembra interessante.
Daniel Buckmaster,

È come uno dei commenti di cui sopra. Sovraccarico di + = e operatore virgola. Mettendo la parentesi per chiarezza: ((((v+=1),2),3),4),5) Ecco come funziona: in primo luogo, vector<T> += Trestituisce un vettore_inserter consente di chiamarlo viche incapsula il vettore originale, quindi vi,Taggiunge T al vettore originale che viincapsula e restituisce se stesso in modo che possiamo fare di vi,Tnuovo.
Piti Ongmongkolkul,

questo codice non ha funzionato correttamente su gcc 4.2.1 penso a causa della restituzione del riferimento a una variabile locale all'interno dell'operatore + = ma l'idea è eccellente. ho modificato il codice e appare un altro costruttore di copie. il flusso è ora -> + = -> ctor -> virgola -> copia -> dtor -> virgola ...... -> virgola -> dtor.
Yevhen,

Probabilmente avrei sovraccaricato << invece di + =. Almeno << ha già regole vaghe per gli effetti collaterali a causa di spostamenti di bit e cout
Speed8ump

11

In C ++ 11:

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

21
Se stai già utilizzando C ++ 11, puoi anche optare per l'approccio diretto - vector<int> arr = {10, 20, 30};.
Bernhard Barker,

In realtà avevo un int [] in arrivo (un po 'di C lib) e volevo inserire un vettore (lib di C ++). Questa risposta ha aiutato, il resto no ;-)
Nebulosa

10

puoi farlo usando boost :: assegnare.

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

dettagli qui


19
Non vedo un caso peggiore di sovraccarico da parte dell'operatore da molto tempo. Esegue il +=tack su 1,2,3,4 .. alla fine dei valori o aggiunge 1 al 1o elemento, 2 al 2o elemento, 3 al 3o elemento (poiché la sintassi come questa dovrebbe in MATLAB- come le lingue)
bobobobo

10

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)

7

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.


5

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!


4

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

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>

La domanda afferma C ++ 03 (non 11)
Mike P

1
Penso che non abbia specificato 03 quando ho risposto a questo. Non ricordo perfettamente però. Tuttavia, è ancora una risposta utile per chi cerca una soluzione rapida.
Shaveenk,

4
// 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.

4

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 

4

È 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.

3

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.


3

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); 
  1. Inizializzazione come array
vector<int> vect{ 10, 20, 30 };
  1. Inizializzazione da un array
    int arr[] = { 10, 20, 30 }; 
    int n = sizeof(arr) / sizeof(arr[0]); 

    vector<int> vect(arr, arr + n); 
  1. Inizializzazione da un altro vettore
    vector<int> vect1{ 10, 20, 30 }; 

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

2

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


Allo stesso modo, sto cercando di inizializzare la mappa, std :: map <int, bool> catinfo = {{1, false}}; Ma poi ottieni questo errore: in c ++ 98 'catinfo' deve essere inizializzato dal costruttore, non da '{...}'
pdk

2

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


La libreria armadillo lo fa per l'inizializzazione della matrice ma usa l'operatore << invece di una funzione denominata: arma.sourceforge.net/docs.html#element_initialisation
Agnel Kurian,

0

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

auto my_ints = {1,2,3};

0

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;
}
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.