Was ist der einfachste Weg, einen std::vector mit fest kodierten Elementen zu initialisieren?

Question

Ich kann ein Array erstellen und es wie folgt initialisieren:

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

Wie kann ich eine std::vector und sie ähnlich elegant initialisieren?

Das ist der beste Weg, den ich kenne:

std::vector<int> ints;

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

Gibt es einen besseren Weg?

Answer 1

Wenn Ihr Compiler C++11 unterstützt, können Sie dies einfach tun:

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

Dies ist im GCC verfügbar ab Version 4.4 . Leider scheint VC++ 2010 in dieser Hinsicht hinterherzuhinken.

Alternativ dazu kann die Boost.Zuweisen Bibliothek verwendet Nicht-Makro-Magie, um das Folgende zu ermöglichen:

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

Oder:

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

Bedenken Sie jedoch, dass dies mit einem gewissen Aufwand verbunden ist (im Wesentlichen, list_of konstruiert eine std::deque unter der Haube), so dass Sie bei leistungsrelevantem Code besser vorgehen sollten, wie Yacoby sagt.

Answer 2

Eine Methode wäre, das Array zur Initialisierung des Vektors zu verwenden

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

Answer 3

Wenn Sie können, verwenden Sie die moderne C++[11,14,17,20,...] Methode:

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

Die alte Methode der Schleifenbildung über ein Array variabler Länge oder die Verwendung von sizeof() ist wirklich schrecklich für die Augen und völlig unnötig in Bezug auf den geistigen Aufwand. Igitt.

Answer 4

In C++0x können Sie dies auf die gleiche Weise wie bei einem Array tun, aber nicht im aktuellen Standard.

Sie können nur Sprachunterstützung verwenden:

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

Wenn Sie andere Bibliotheken hinzufügen können, könnten Sie boost::assignment ausprobieren:

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

Um die feste Kodierung der Größe eines Arrays zu vermeiden:

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

Answer 5

In C++11:

#include <vector>
using std::vector;
...
vector<int> vec1 { 10, 20, 30 };
// or
vector<int> vec2 = { 10, 20, 30 };

Verwendung von Boost list_of :

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

Mit Boost zuweisen:

#include <vector>
#include <boost/assign/std/vector.hpp>
using std::vector;
...
vector<int> vec;
vec += 10, 20, 30;

Konventionelle STL:

#include <vector>
using std::vector;
...
static const int arr[] = {10,20,30};
vector<int> vec (arr, arr + sizeof(arr) / sizeof(arr[0]) );

Konventionelle STL mit generischen Makros:

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

Konventionelle STL mit einem Vektor-Initialisierungsmakro:

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