Qual é a maneira mais fácil de inicializar um std :: vector com elementos codificados?

Eu posso criar uma matriz e inicializá-la assim:

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

Como crio std::vectore inicializo de forma semelhante elegante?

A melhor maneira que eu sei é:

std::vector<int> ints;

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

Existe uma maneira melhor?

Um método seria usar a matriz para inicializar o vetor

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

Se o seu compilador suportar C ++ 11, você pode simplesmente:

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

Está disponível no GCC a partir da versão 4.4 . Infelizmente, o VC ++ 2010 parece estar atrasado nesse aspecto.

Como alternativa, a biblioteca Boost.Assign usa magia não macro para permitir o seguinte:

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

Ou:

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

Mas lembre-se de que isso tem alguma sobrecarga (basicamente, list_ofconstrói um std::dequesob o capô); portanto, para um código crítico de desempenho, seria melhor fazer o que Yacoby diz.

Se você puder, use o modo C ++ [11,14,17, ...] moderno:

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

A velha maneira de fazer um loop em uma matriz de comprimento variável ou usar sizeof()é realmente terrível para os olhos e completamente desnecessária em termos de sobrecarga mental. Que nojo.

No C ++ 0x, você poderá fazer da mesma maneira que fez com uma matriz, mas não no padrão atual.

Com apenas suporte ao idioma, você pode usar:

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

Se você pode adicionar outras bibliotecas, tente o boost :: assignment:

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

Para evitar codificar o tamanho de uma 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))

No 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 o boost assign:

#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 com 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 com uma macro de inicialização de vetor:

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

Só pensei em jogar meus $ 0,02. Costumo declarar isso:

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

em um cabeçalho de utilitário em algum lugar e, em seguida, tudo o que é necessário é:

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

Mas mal posso esperar pelo C ++ 0x. Estou preso porque meu código também deve ser compilado no Visual Studio. Vaia.

Antes do 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 em diante também é possível

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

Começando com:

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

Se você não possui um compilador C ++ 11 e não deseja usar o 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 você não possui um compilador C ++ 11 e pode usar o boost:

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

Se você possui um compilador C ++ 11:

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

Para inicialização de vetor -

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

Isso pode ser feito se você tiver o compilador c ++ 11.

Senão, você pode ter uma matriz de dados e usar um loop for.

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

Além disso, existem várias outras maneiras descritas acima usando algum código. Na minha opinião, essas maneiras são fáceis de lembrar e rápidas de escrever.

A maneira mais fácil de fazer isso é:

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

Eu construo minha própria solução usando va_arg. Esta solução é compatível com 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

Se o seu compilador suportar macros Variadic (o que é verdadeiro para a maioria dos compiladores modernos), você poderá usar a macro a seguir para transformar a inicialização de vetor em uma linha única:

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

Com essa macro, você pode definir um vetor inicializado com código como este:

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

Isso criaria um novo vetor de ints chamado my_vector com os elementos 1, 2, 3, 4.

Se você não deseja usar o impulso, mas deseja desfrutar de sintaxe como

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

basta incluir este pedaço 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;
}

No C ++ 11:

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

você pode fazer isso usando boost :: assign.

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

detalhe aqui

Uma pergunta duplicada mais recente tem essa resposta de Viktor Sehr . Para mim, é compacto, visualmente atraente (parece que você está 'empurrando' os valores), não requer c ++ 11 ou um módulo de terceiros e evita o uso de uma variável extra (escrita). Abaixo está como eu o uso com algumas alterações. Eu posso mudar para estender a função de vetor e / ou va_arg no 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)

Os métodos abaixo podem ser usados ​​para inicializar o vetor em 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 assim por diante

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

O terceiro é permitido apenas no C ++ 11 em diante.

Há muitas respostas boas aqui, mas desde que cheguei sozinha antes de ler isso, achei que jogaria as minhas aqui de qualquer maneira ...

Aqui está um método que estou usando para isso que funcionará universalmente em compiladores e plataformas:

Crie uma estrutura ou classe como um contêiner para sua coleção de objetos. Defina uma função de sobrecarga do operador para <<.

class MyObject;

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

Você pode criar funções que tomam sua estrutura como um parâmetro, por exemplo:

someFunc( MyObjectList &objects );

Em seguida, você pode chamar essa função, assim:

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

Dessa forma, você pode criar e transmitir uma coleção de objetos de tamanho dinâmico para uma função em uma única linha limpa!

Se você deseja algo na mesma ordem geral que o Boost :: assign sem criar uma dependência do Boost, o seguinte é pelo menos vagamente semelhante:

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

Embora eu deseje que a sintaxe para usá-lo seja mais limpa, ainda não é particularmente terrível:

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, use:

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 a matriz for:

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 

É bastante conveniente criar um vetor embutido sem definir variável ao escrever teste, por exemplo:

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

Relacionado, você pode usar o seguinte se quiser ter um vetor completamente pronto para uma declaração rápida (por exemplo, passar imediatamente para outra função):

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

função de exemplo

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

exemplo de uso

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

embora tenha cuidado com o decltype, verifique se o primeiro valor é claramente o que você deseja.

Existem várias maneiras de codificar um vetor, compartilharei algumas maneiras:

1. Inicializando pressionando valores um por um

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

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

2. Inicializando como matrizes

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

3. Inicializando a partir de uma matriz

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

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

4. Inicializando de outro vetor

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

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

"Como crio um vetor STL e o inicializo como acima? Qual é a melhor maneira de fazer isso com o mínimo esforço de digitação?"

A maneira mais fácil de inicializar um vetor quando você inicializou sua matriz interna é usando uma lista de inicializadores que foi introduzida no 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 tem 3 elementos em tamanho após a execução de Assigning (instrução rotulada).

B. Stroustrup descreve uma boa maneira de encadear operações na 16.2.10 Selfreference na página 464 na edição C ++ 11 do Prog. Lang. onde uma função retorna uma referência, modificada aqui para um vetor. Dessa forma, você pode encadear como, v.pb(1).pb(2).pb(3);mas pode ser muito trabalhoso para ganhos tão pequenos.

#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

A maneira mais simples e ergonômica (com C ++ 11 ou posterior):

auto my_ints = {1,2,3};

Caso você queira tê-lo em sua própria 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;
}