¿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 inicializo un estilo igualmente elegante?

La mejor manera que sé es:

std::vector<int> ints;

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

¿Hay una mejor manera?

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

Si su compilador admite C ++ 11, simplemente puede hacer:

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

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

Alternativamente, la biblioteca Boost.Assign usa 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 algo de sobrecarga (básicamente, list_ofconstruye un std::dequebajo el capó), por lo que para un código crítico de rendimiento sería mejor que haga como dice Yacoby.

Si puede, use el moderno C ++ [11,14,17, ...]:

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

La antigua forma de bucle sobre una matriz de longitud variable o uso sizeof()es realmente terrible a los ojos y completamente innecesaria en términos de sobrecarga mental. Yuck

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 intentar aumentar :: asignación:

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

En C ++ 11:

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

Usando boost list_of:

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

Usando la asignación de impulso:

#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éricos:

#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 de vector:

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

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.

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 a continuación también es posible

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

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 desea 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 tienes un compilador de C ++ 11:

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

Para la inicialización del vector:

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

se puede hacer si tienes el compilador de 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]);
}

Además 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.

La forma más fácil de hacerlo es:

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

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

Manifestación

Si su compilador admite macros Variadic (lo cual es cierto para la mayoría de los compiladores modernos), puede usar la siguiente macro para convertir la inicialización de vectores en una 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 entradas llamado my_vector con los elementos 1, 2, 3, 4.

Si no quieres usar boost, pero quieres disfrutar de 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;
}

En C ++ 11:

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

puedes hacerlo usando boost :: asignar.

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

detalle aquí

Una pregunta duplicada más reciente tiene esta respuesta de Viktor 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)

Los siguientes métodos se pueden usar 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 solo está permitido en C ++ 11 en adelante.

Hay muchas buenas respuestas aquí, pero como llegué a mi propia pregunta 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. Defina 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!

Si desea algo en el mismo orden general que Boost :: asignar 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 deseo que la sintaxis para usarla sea más limpia, todavía no es particularmente 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

Para compilar el uso:

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

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

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

Relacionado, puede usar lo siguiente si desea tener un vector completamente listo para ir 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 decltype, asegúrese de que el primer valor sea claramente el que desea.

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

2. Inicializando como matrices

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

3. Inicializando desde una matriz

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

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

4. Inicializando desde otro vector

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

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

"¿Cómo creo un vector STL e 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 como ha inicializado su matriz incorporada es usar una lista de inicializador 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 3 elementos de tamaño después de ejecutar Asignación (declaración etiquetada).

B. Stroustrup describe una buena manera de encadenar operaciones en 16.2.10 Self Reference en la página 464 en la edición C ++ 11 del Prog. Lang. donde una función devuelve una referencia, aquí modificada a un vector. De esta manera puede encadenar, 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

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

auto my_ints = {1,2,3};

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