Je peux créer un tableau et l'initialiser comme ceci :
int a[] = {10, 20, 30};
Comment puis-je créer un std::vector
et l'initialiser de manière aussi élégante ?
La meilleure façon que je connaisse est :
std::vector<int> ints;
ints.push_back(10);
ints.push_back(20);
ints.push_back(30);
Y a-t-il un meilleur moyen ?
Si votre compilateur supporte C++11, vous pouvez simplement faire :
std::vector<int> v = {1, 2, 3, 4};
Ceci est disponible dans GCC [à partir de la version 4.4] (http://gcc.gnu.org/projects/cxx0x.html). Malheureusement, VC++ 2010 semble être à la traîne à cet égard.
Alternativement, la bibliothèque Boost.Assign utilise la magie non-macro pour permettre ce qui suit :
#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;
Mais gardez à l'esprit que cela a une certaine surcharge (en gros, list_of
construit un std::deque
sous le capot) donc pour du code critique en terme de performance, vous feriez mieux de faire comme Yacoby.
En C++0x, vous pourrez le faire de la même manière qu'avec un tableau, mais pas dans la norme actuelle.
Avec le seul support du langage, vous pouvez utiliser :
int tmp[] = { 10, 20, 30 };
std::vector<int> v( tmp, tmp+3 ); // use some utility to avoid hardcoding the size here
Si vous pouvez ajouter d'autres bibliothèques, vous pouvez essayer boost::assignment :
vector<int> v = list_of(10)(20)(30);
Pour éviter de coder en dur la taille d'un tableau :
// 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))