Eu posso criar um array e inicializá-lo assim:
int a[] = {10, 20, 30};
Como posso criar um std::vector
e inicializá-lo de forma igualmente elegante?
A melhor maneira que eu conheço é:
std::vector<int> ints;
ints.push_back(10);
ints.push_back(20);
ints.push_back(30);
Há uma maneira melhor?
Se o seu compilador suporta C++11, você pode simplesmente fazer:
std::vector<int> v = {1, 2, 3, 4};
Isto está disponível no GCC a partir da versão 4.4. Infelizmente, o VC++ 2010 parece estar atrasado a este respeito.
Alternativamente, a biblioteca Boost.Assign usa magia sem 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 tenha em mente que isso tem algum overhead (basicamente, list_of
constrói um std::deque
sob o capô) então para código crítico de performance você'seria melhor fazer como diz Yacoby.
Em C++0x você será capaz de fazê-lo da mesma forma que o fez com um array, mas não no padrão atual.
Com apenas suporte de 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ê puder adicionar outras bibliotecas, você pode tentar impulsionar::assignment:
vector<int> v = list_of(10)(20)(30);
Para evitar a codificação dura do 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))