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

Question 1

Ich kann ein Array erstellen und es folgendermaßen initialisieren:

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

Wie erstelle ich eine std::vector und gleich elegant initialisieren?

Der beste Weg, den ich kenne, ist:

std::vector<int> ints;

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

Gibt es einen besseren Weg?

Question 2

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

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

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

Alternativ die Boost.Assign Die Bibliothek verwendet Nicht-Makro-Magie, um Folgendes 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;

Aber denken Sie daran, dass dies einen gewissen Overhead hat (im Grunde genommen list_of baut ein std::deque unter der Haube), also sollten Sie für leistungskritischen Code besser tun, was Yacoby sagt.

Question 3

Eine Methode wäre, das Array zu verwenden, um den Vektor zu initialisieren

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

Question 4

Verwenden Sie nach Möglichkeit das moderne C++[11,14,17,20,…] Weg:

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

Die alte Art, ein Array mit variabler Länge zu durchlaufen oder zu verwenden sizeof() ist wirklich schrecklich für die Augen und völlig unnötig in Bezug auf den mentalen Overhead. Yuck.

Question 5

In C++0x können Sie das genauso machen wie mit einem Array, aber nicht im aktuellen Standard.

Nur mit Sprachunterstützung können Sie Folgendes 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);

So vermeiden Sie die Festcodierung der Größe eines Arrays:

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

Question 6

In C++11:

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

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

Verwenden von Boost-Zuweisung:

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

Herkömmliche 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));

Herkömmliche STL mit einem Vektor-Initialisierer-Makro:

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

Question 7

Ich neige dazu, zu erklären

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

irgendwo in einem Utility-Header und dann ist alles, was erforderlich ist:

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

Question 8

Vor C++ 11:

Methode 1

vector<int> v(arr, arr + sizeof(arr)/sizeof(arr[0]));
vector<int>v;

Methode 2

 v.push_back(SomeValue);

C++ 11 und darunter ist ebenfalls möglich

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

Das können wir auch

vector<int>v {1, 3, 5, 7}; // Notice .. no "=" sign

Ab C++ 17 können wir den Typ weglassen

vector v = {1, 3, 5, 7};