Ik kan een array maken en hem zo initialiseren:
int a[] = {10, 20, 30};
Hoe maak ik een std::vector
en initialiseer die op dezelfde elegante manier?
De beste manier die ik ken is:
std::vector<int> ints;
ints.push_back(10);
ints.push_back(20);
ints.push_back(30);
Is er een betere manier?
Als uw compiler C++11 ondersteunt, kunt u gewoon doen:
std::vector<int> v = {1, 2, 3, 4};
Dit is beschikbaar in GCC vanaf versie 4.4. Helaas lijkt VC++ 2010 op dit punt achter te lopen.
Als alternatief gebruikt de Boost.Assign bibliotheek niet-macro magie om het volgende mogelijk te maken:
#include <boost/assign/list_of.hpp>
...
std::vector<int> v = boost::assign::list_of(1)(2)(3)(4);
Of:
#include <boost/assign/std/vector.hpp>
using namespace boost::assign;
...
std::vector<int> v;
v += 1, 2, 3, 4;
Maar vergeet niet dat dit wat overhead heeft (in principe construeert list_of
een std::deque
onder de motorkap) dus voor performance-kritische code kun je beter doen wat Yacoby zegt.
In C++0x zult u het op dezelfde manier kunnen doen als met een array, maar niet in de huidige standaard.
Met alleen taalondersteuning kunt u gebruiken:
int tmp[] = { 10, 20, 30 };
std::vector<int> v( tmp, tmp+3 ); // use some utility to avoid hardcoding the size here
Als je andere bibliotheken kunt toevoegen zou je boost::assignment kunnen proberen:
vector<int> v = list_of(10)(20)(30);
Om hardcoding van de grootte van een array te vermijden:
// 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))