Pregunta ¿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 de manera similar elegante?

La mejor manera que conozco es:

std::vector<int> ints;

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

¿Hay una mejor manera?


507
2018-02-10 10:55


origen


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

482
2018-02-10 11:00



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. Lamentablemente, VC ++ 2010 parece estar rezagado en este sentido.

Alternativamente, el Boost.Assign 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 ten 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.


512
2018-02-10 11:01



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

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

Para evitar codificar de forma rígida 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))

70
2018-02-10 11:00



Solo pensé en tirar mi $ 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 alguna parte 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 para C ++ 0x. Estoy atascado porque mi código también debe compilarse en Visual Studio. Abucheo.


48
2018-04-03 04:15



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

46
2017-10-07 21:30



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

31
2017-08-03 09:13



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 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 C ++ 11:

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

25
2017-12-12 00:01



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

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

20
2018-01-24 18:29