¿Cuál es la forma más fácil de inicializar un std :: vector con elementos codificados?

Puedo crear una matriz e inicializarla así:

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

¿Cómo creo un std::vector e inicializarlo igualmente elegante?

La mejor forma que conozco es:

std::vector<int> ints;

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

¿Hay una mejor manera?

preguntado el 10 de febrero de 10 a las 07:02

Si no va a cambiar el tamaño de las entradas después de la inicialización, considere usar la matriz tr1. -

@zr, me tiene curiosidad ... si necesitara un tamaño fijo, ¿no podría usar matrices antiguas? Mirando la matriz tr1 ahora mismo ... -

tr1::array es útil porque las matrices ordinarias no proporcionan la interfaz de los contenedores STL -

Se modificó el título para convertirla explícitamente en una pregunta de C ++ 03. Parecía más fácil que revisar y corregir todas las respuestas para que tuvieran sentido con el nuevo estándar C ++. -

29 Respuestas

Un método sería usar la matriz para inicializar el vector

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

Respondido 10 Feb 10, 13:02

@Agnel Funcionará bien sin static or const, sin embargo, ambos hacen más explícito cómo se debe usar y permiten que el compilador realice optimizaciones adicionales. - Yacoby

No lo menosprecié, pero me sentí tentado. Principalmente porque esto le ahorra casi nada más que simplemente usar la matriz inicializada en primer lugar. Sin embargo, eso es realmente culpa de C ++, no tuya. - TED

¿Puede explicar por qué está utilizando esos parámetros al definir el vector vec. - DomX23

sizeof (matriz) es una de las pocas excepciones que permite obtener el tamaño total de los elementos de la matriz y NO la dimensión del puntero arr. Básicamente, está usando vector (pointer_to_first_element, pointer_to_first_element + size_in_bytes_of_the_whole_array / size_of_one_element) que es: vector (pointer_to_first_element, pointer_after_final_element). El tipo ya viene con el , por lo que el vector sabe cuánto es un elemento. Recuerde que los iteradores se pueden tratar como punteros, por lo que básicamente está utilizando el constructor de vector (comienzo del iterador, final del iterador): johnny pauling

@TED: A veces es necesario modificar el vector resultante. Por ejemplo, es posible que deba tener siempre algunos parámetros predeterminados y, a veces, agregar algunos personalizados. - DarkWanderer

Si su compilador es compatible con C ++ 11, simplemente puede hacer:

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

Esto está disponible en GCC a partir de la versión 4.4. Desafortunadamente, VC ++ 2010 parece estar rezagado en este sentido.

Alternativamente, el Impulsar Asignar la biblioteca utiliza magia no macro para permitir lo siguiente:

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

Pero tenga en cuenta que esto tiene algunos gastos generales (básicamente, list_of construye un std::deque bajo el capó), por lo que para el código de rendimiento crítico sería mejor hacer lo que dice Yacoby.

respondido 09 nov., 13:00

Dado que los vectores son de tamaño propio, ¿estaría bien inicializarlos como vacíos también? Como en el constructor: this->vect = {}; ? - Punto azur

@Azurespot Puede inicializarlo y estará vacío: std::vector<T> vector; - Luke

En caso de que alguien sienta curiosidad por std::vector<int> v = {1, 2, 3, 4};, vector de initializer list constructor se llamará para este tipo de inicialización, su documento se puede encontrar en el C++ 11 .. - simomo

Si puede, use la forma moderna de C ++ [11,14,17, ...]:

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

La antigua forma de recorrer una matriz de longitud variable o usar sizeof() es realmente terrible a la vista y completamente innecesario en términos de sobrecarga mental. ¡Qué asco!

Respondido 27 Feb 19, 12:02

Para ser justos, esta fue originalmente una pregunta de C ++ 03, pero espero que las personas / empresas adopten los nuevos estándares. C ++ todavía necesita una implementación de matriz de longitud variable (VLA) en la biblioteca estándar similar a la que está disponible en Eigen y Boost. - adam erickson

Desafortunadamente, este enfoque es problemático en algunos casos, p. Ej. open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1467. ¡Qué asco! - Carreras de ligereza en órbita

Si lo suyo es la "inicialización de lista de un agregado de un objeto del mismo tipo", probablemente haya problemas mayores en su base de código ... No puedo pensar en ninguna aplicación en la que justifique los problemas de depuración. - adam erickson

respuesta de 2018 y todavía usa ={}? - Nadie

Todavía no hay necesidad de = - barra invertidaN

En C ++ 0x podrá hacerlo de la misma manera que lo hizo con una matriz, pero no en el estándar actual.

Con solo soporte de idiomas, puede usar:

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

Si puede agregar otras bibliotecas, puede probar boost :: assign:

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

Para evitar codificar el tamaño de una matriz:

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

Respondido 30 Jul 13, 14:07

Por supuesto, no voté negativamente, pero tengo una pregunta de todos modos: ¿cuándo el tamaño de una matriz no es una constante de tiempo de compilación? Es decir, ¿en qué casos usaría la primera solución en su segundo fragmento en lugar de la tercera? - Manuel

@Manuel, el tamaño de la matriz es parte del tipo y, como tal, es una constante de tiempo de compilación. Ahora, la opción 1 usa esa constante de tiempo de compilación 'N' como valor de retorno para una función. El retorno de una función no es un tiempo de compilación, sino un valor de tiempo de ejecución, incluso si probablemente se incluirá como valor constante en el lugar de la llamada. La diferencia es que no puedes hacer: int another[size_of_array(array)], mientras puedas hacer int another[ARRAY_SIZE(array)]. - David Rodríguez - Dribeas

En la opción 3: ¿Realmente no entiendo lo que quieres decir con "declarado, indefinido"? Entonces, ¿la variable no ocupará memoria adicional? - To1ne

@ To1ne eso es en realidad una declaración de función, no una variable. La razón para definirla es que en realidad no queremos la función para otra cosa que no sea la sizeof expresión que no necesita definición. Si bien puede proporcionar una definición, hacerlo bien requeriría la asignación estática de una matriz y devolver una referencia a ella, y la siguiente pregunta sería ¿qué tendría sentido como valores para la matriz? (¡Tenga en cuenta también que esto significa una matriz por combinación de tipo / tamaño de las instancias de la función!) Dado que no es un uso sensato, prefiero evitarlo. - David Rodríguez - Dribeas

@mhd: no puede construir una matriz vacía en el idioma. 'int arr [0] = {};' no es un código C ++ válido. Pero tiene razón en que si desea inicializar un vector vacío y un vector no vacío, tendrá que usar diferentes construcciones. Desde C ++ 11, esto no es un problema, ya que puede usar el constructor de la lista de inicializadores: David Rodríguez - Dribeas

En C ++ 11:

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

Usando impulso list_of:

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

Usando boost asignar:

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

STL convencional:

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

STL convencional con macros genéricas:

#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 convencional con una macro de inicializador vectorial:

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

Respondido 07 Jul 20, 14:07

C ++ 11 también es compatible std::begin y std::end para matriz, por lo que un vector también se puede inicializar como static const int arr[] = {10,20,30}; vector<int> vec(begin(arr), end(arr));. - Jaege

Solo pensé en tirar mis $ 0.02. Tiendo a declarar esto:

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

en un encabezado de utilidad en algún lugar y luego todo lo que se requiere es:

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

Pero no puedo esperar a C ++ 0x. Estoy atascado porque mi código también debe compilarse en Visual Studio. Abucheo.

Respondido 03 Abr '11, 05:04

Esta técnica también se puede utilizar para sobrecargar una función para aceptar una matriz con tamaño escrito. - Andrés Riofrío

¿Puedes explicar el const T (&data)[N] ¿parte? ¿Cómo se deduce el tamaño de la matriz en su llamada? makeVector(values)? - Patryk

Antes de C ++ 11:

Método 1 =>

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

Método 2 =>

 v.push_back(SomeValue);

C ++ 11 en adelante también es posible

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

Respondido el 20 de diciembre de 16 a las 05:12

Empezando con:

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

Si no tiene un compilador de C ++ 11 y no quiere usar 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 no tiene un compilador de C ++ 11 y puede usar boost:

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

Si tiene un compilador de C ++ 11:

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

Respondido el 12 de diciembre de 14 a las 00:12

Para inicialización vectorial -

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

se puede hacer si tiene el compilador C ++ 11.

De lo contrario, puede tener una matriz de datos y luego usar un bucle for.

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

Aparte de estos, hay varias otras formas descritas anteriormente utilizando algún código. En mi opinión, estas formas son fáciles de recordar y rápidas de escribir.

Respondido 07 Jul 20, 14:07

La forma más sencilla de hacerlo es:

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

Respondido 18 Feb 13, 21:02

¿Qué compilador? ¿Estás usando C ++ 11 aquí? - agnel kurian

g ++ 4.6.3 con -std = c ++ 0x. - Pablo Baltescu

Construyo mi propia solución usando va_arg. Esta solución es compatible con 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;
}

Demo

Respondido el 12 de junio de 19 a las 12:06

Si su compilador admite Macros variadic (que es cierto para la mayoría de los compiladores modernos), entonces puede usar la siguiente macro para convertir la inicialización de vector en una sola línea:

#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 esta macro, puede definir un vector inicializado con un código como este:

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

Esto crearía un nuevo vector de ints llamado my_vector con los elementos 1, 2, 3, 4.

Respondido el 25 de Septiembre de 10 a las 19:09

Si no quiere usar boost, pero quiere disfrutar de una sintaxis como

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

solo incluye este fragmento de código

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

respondido 07 nov., 16:21

No he podido averiguar cómo usar este código, pero parece interesante. - daniel buckmaster

Es como dijo uno de los comentarios anteriores. Solo sobrecarga + = y operador de coma. Poner paréntesis para mayor claridad: ((((v+=1),2),3),4),5) Así es como funciona: Primero, vector<T> += T devuelve un vector_inserter vamos a llamarlo vi que encapsulan el vector original luego vi,T agregue T al vector original que vi encapsular y devolver a sí mismo para que podamos hacer vi,T de nuevo. - Piti Ongmongkolkul

este código no funcionó correctamente en gcc 4.2.1, creo que debido a que devuelve una referencia a una variable local dentro del operador + =, pero la idea es excelente. Edité el código y aparece un constructor de copia más. el flujo es ahora -> + = -> ctor -> coma -> copiar -> dtor -> coma ...... -> coma -> dtor. - Yevhen

Probablemente habría sobrecargado << en lugar de + =. Al menos << ya tiene reglas vagas de efectos secundarios debido a cambios de bits y cout - Velocidad8ump

En C ++ 11:

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

Respondido 24 Feb 15, 13:02

Si ya está usando C ++ 11, también puede optar por el enfoque directo: vector<int> arr = {10, 20, 30};. - Bernardo Barker

En realidad, tenía un int [] entrante (algo de C lib) y quería insertarlo en un vector (C ++ lib). Esta respuesta ayudó, el resto no ;-) - Nebula

puedes hacerlo usando boost :: assign.

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

detalle aquí

Respondido 10 Feb 10, 11:02

No he visto un caso peor de abuso por sobrecarga de operadores en mucho tiempo. ¿El += hay virajes en 1,2,3,4 .. al final de los valores, o no add 1 al primer elemento, 1 al segundo elemento, 2 al tercer elemento (como una sintaxis como esta debería en lenguajes similares a MATLAB) - bobobobo

Una pregunta duplicada más reciente tiene esta respuesta by Victor Sehr. Para mí, es compacto, visualmente atractivo (parece que está 'introduciendo' los valores), no requiere c ++ 11 o un módulo de terceros y evita el uso de una variable adicional (escrita). A continuación se muestra cómo lo estoy usando con algunos cambios. Puedo cambiar a extender la función de vector y / o va_arg en el futuro 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)

Respondido 07 Jul 20, 14:07

Los métodos siguientes se pueden utilizar para inicializar el vector 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); y así

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

El tercero está permitido solo en C ++ 11 en adelante.

Respondido 02 ago 16, 15:08

Hay muchas buenas respuestas aquí, pero como llegué a la mía de forma independiente antes de leer esto, pensé que arrojaría la mía aquí de todos modos ...

Aquí hay un método que estoy usando para esto que funcionará universalmente en compiladores y plataformas:

Cree una estructura o clase como contenedor para su colección de objetos. Definir una función de sobrecarga del operador para <<.

class MyObject;

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

Puede crear funciones que tomen su estructura como parámetro, por ejemplo:

someFunc( MyObjectList &objects );

Entonces, puede llamar a esa función, así:

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

De esa manera, puede construir y pasar una colección de objetos de tamaño dinámico a una función en una sola línea limpia.

Respondido 07 Jul 20, 14:07

Si desea algo en el mismo orden general que Boost :: assign sin crear una dependencia en Boost, lo siguiente es al menos vagamente similar:

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

Si bien desearía que la sintaxis para usarlo fuera más limpia, todavía no es particularmente horrible:

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

Respondido 10 Feb 10, 19:02

typedef std::vector<int> arr;

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

Para compilar el uso:

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

Respondido 30 ago 14, 13:08

Pregunta afirma C ++ 03 (no 11) - Mike P

Creo que no especificó 03 cuando respondí esto. Sin embargo, no lo recuerdo perfectamente. Sin embargo, sigue siendo una respuesta útil para quienes buscan una solución rápida. - afeitarse

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

respondido 18 nov., 16:01

Si la matriz es:

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 

Respondido el 13 de diciembre de 17 a las 18:12

Es bastante conveniente crear un vector en línea sin definir una variable al escribir la prueba, por ejemplo:

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

Respondido el 03 de diciembre de 19 a las 14:12

Hay varias formas de codificar un vector, compartiré algunas formas:

  1. Inicializando presionando valores uno por uno
// Create an empty vector 
    vector<int> vect;  

    vect.push_back(10); 
    vect.push_back(20); 
    vect.push_back(30); 
  1. Inicializando matrices similares
vector<int> vect{ 10, 20, 30 };
  1. Inicializando desde una matriz
    int arr[] = { 10, 20, 30 }; 
    int n = sizeof(arr) / sizeof(arr[0]); 

    vector<int> vect(arr, arr + n); 
  1. Inicializando desde otro vector
    vector<int> vect1{ 10, 20, 30 }; 

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

contestado el 27 de mayo de 20 a las 19:05

"¿Cómo creo un vector STL y lo inicializo como el anterior? ¿Cuál es la mejor manera de hacerlo con el mínimo esfuerzo de escritura?"

La forma más fácil de inicializar un vector una vez que ha inicializado su matriz incorporada es usando una lista de inicializadores que se introdujo 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 tiene un tamaño de 3 elementos después de ejecutar la Asignación (instrucción etiquetada).

Respondido 07 Jul 20, 14:07

En líneas similares, estoy tratando de inicializar el mapa, std :: map catinfo = {{1, falso}}; Pero luego aparece este error: en C ++ 98 'catinfo' debe ser inicializado por el constructor, no por '{...}' - pdk

Relacionado, puede usar lo siguiente si desea tener un vector completamente listo para usar en una declaración rápida (por ejemplo, pasar inmediatamente a otra función):

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

función de ejemplo

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

ejemplo de uso

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

aunque tenga cuidado con el tipo de declinación, asegúrese de que el primer valor sea claramente el que desea.

contestado el 07 de mayo de 13 a las 02:05

B. Stroustrup describe una buena manera de encadenar operaciones en 16.2.10 Autorreferencia en la página 464 en la edición C ++ 11 de Prog. Lang. donde una función devuelve una referencia, aquí modificada a un vector. De esta manera puedes encadenar como v.pb(1).pb(2).pb(3); pero puede ser demasiado trabajo para ganancias tan pequeñas.

#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

Respondido 17 Feb 16, 22:02

La biblioteca de armadillo hace esto para la inicialización de la matriz, pero usa el operador << en lugar de una función con nombre: arma.sourceforge.net/docs.html#element_initialisation - agnel kurian

La forma más simple y ergonómica (con C ++ 11 o posterior):

auto my_ints = {1,2,3};

Respondido el 26 de Septiembre de 20 a las 15:09

En caso de que quieras tenerlo en tu propia clase:

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

Respondido el 05 de junio de 20 a las 17:06

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.