Apa cara termudah untuk menginisialisasi std :: vektor dengan elemen hardcoded?

Saya bisa membuat array dan menginisialisasi seperti ini:

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

Bagaimana cara membuat std::vectordan menginisialisasikannya dengan cara yang elegan?

Cara terbaik yang saya tahu adalah:

std::vector<int> ints;

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

Apakah ada cara yang lebih baik?

Salah satu metode adalah menggunakan array untuk menginisialisasi vektor

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

Jika kompiler Anda mendukung C ++ 11, Anda dapat melakukannya:

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

Ini tersedia dalam GCC pada versi 4.4 . Sayangnya, VC ++ 2010 tampaknya tertinggal dalam hal ini.

Atau, perpustakaan Boost.Assign menggunakan sihir non-makro untuk memungkinkan yang berikut:

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

Atau:

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

Tetapi perlu diingat bahwa ini memiliki beberapa overhead (pada dasarnya, list_ofmembangun di std::dequebawah kap) sehingga untuk kode kinerja-kritis Anda akan lebih baik melakukan seperti kata Yacoby.

Jika Anda bisa, gunakan cara C ++ modern [11,14,17, ...]:

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

Cara lama pengulangan pada array panjang variabel atau menggunakan sizeof()benar-benar mengerikan di mata dan benar-benar tidak perlu dalam hal overhead mental. Yuck.

Dalam C ++ 0x Anda akan dapat melakukannya dengan cara yang sama seperti yang Anda lakukan dengan array, tetapi tidak dalam standar saat ini.

Dengan hanya dukungan bahasa yang dapat Anda gunakan:

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

Jika Anda dapat menambahkan perpustakaan lain, Anda dapat mencoba meningkatkan :: tugas:

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

Untuk menghindari hardcoding ukuran array:

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

Dalam C ++ 11:

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

Menggunakan boost list_of:

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

Menggunakan boost boost:

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

STL konvensional:

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

STL konvensional dengan makro umum:

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

STL konvensional dengan makro penginisialisasi vektor:

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

Hanya berpikir saya akan melemparkan $ 0,02 saya. Saya cenderung menyatakan ini:

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

di header utilitas di suatu tempat dan kemudian semua yang diperlukan adalah:

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

Tapi saya tidak sabar menunggu C ++ 0x. Saya macet karena kode saya juga harus dikompilasi di Visual Studio. Boo.

Sebelum C ++ 11:

Metode 1 =>

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

Metode 2 =>

 v.push_back(SomeValue);

C ++ 11 dan seterusnya di bawah ini juga dimungkinkan

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

Dimulai dengan:

int a[] = {10, 20, 30}; //i'm assuming a is just a placeholder

Jika Anda tidak memiliki kompiler C ++ 11 dan Anda tidak ingin menggunakan boost:

const int a[] = {10, 20, 30};
const std::vector<int> ints(a,a+sizeof(a)/sizeof(int)); //make it const if you can

Jika Anda tidak memiliki kompiler C ++ 11 dan dapat menggunakan boost:

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

Jika Anda memiliki kompiler C ++ 11:

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

Untuk inisialisasi vektor -

vector<int> v = {10,20,30}

dapat dilakukan jika Anda memiliki c ++ 11 compiler.

Selain itu, Anda dapat memiliki larik data dan kemudian gunakan untuk loop.

int array[] = {10,20,30}
for(unsigned int i=0; i<sizeof(array)/sizeof(array[0]); i++)
{
     v.push_back(array[i]);
}

Terlepas dari ini, ada berbagai cara lain yang dijelaskan di atas menggunakan beberapa kode. Menurut saya, cara-cara ini mudah diingat dan cepat ditulis.

Cara termudah untuk melakukannya adalah:

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

Saya membangun solusi saya sendiri menggunakan va_arg. Solusi ini sesuai dengan C ++ 98.

#include <cstdarg>
#include <iostream>
#include <vector>

template <typename T>
std::vector<T> initVector (int len, ...)
{
  std::vector<T> v;
  va_list vl;
  va_start(vl, len);
  for (int i = 0; i < len; ++i)
    v.push_back(va_arg(vl, T));
  va_end(vl);
  return v;
}

int main ()
{
  std::vector<int> v = initVector<int> (7,702,422,631,834,892,104,772);
  for (std::vector<int>::const_iterator it = v.begin() ; it != v.end(); ++it)
    std::cout << *it << std::endl;
  return 0;
}

Demo

Jika kompiler Anda mendukung makro Variadic (yang berlaku untuk sebagian besar kompiler modern), maka Anda dapat menggunakan makro berikut untuk mengubah inisialisasi vektor menjadi satu-liner:

#define INIT_VECTOR(type, name, ...) \
static const type name##_a[] = __VA_ARGS__; \
vector<type> name(name##_a, name##_a + sizeof(name##_a) / sizeof(*name##_a))

Dengan makro ini, Anda dapat menentukan vektor yang diinisialisasi dengan kode seperti ini:

INIT_VECTOR(int, my_vector, {1, 2, 3, 4});

Ini akan membuat vektor int baru bernama my_vector dengan elemen 1, 2, 3, 4.

Jika Anda tidak ingin menggunakan boost, tetapi ingin menikmati sintaksis like

std::vector<int> v;
v+=1,2,3,4,5;

cukup sertakan potongan kode ini

template <class T> class vector_inserter{
public:
    std::vector<T>& v;
    vector_inserter(std::vector<T>& v):v(v){}
    vector_inserter& operator,(const T& val){v.push_back(val);return *this;}
};
template <class T> vector_inserter<T> operator+=(std::vector<T>& v,const T& x){
    return vector_inserter<T>(v),x;
}

Dalam C ++ 11:

static const int a[] = {10, 20, 30};
vector<int> vec (begin(a), end(a));

Anda dapat melakukannya menggunakan boost :: assign.

vector<int> values;  
values += 1,2,3,4,5,6,7,8,9;

detail di sini

Pertanyaan duplikat yang lebih baru memiliki jawaban ini oleh Viktor Sehr . Bagi saya, itu kompak, menarik secara visual (sepertinya Anda 'mendorong' nilai-nilai di), tidak memerlukan c ++ 11 atau modul pihak ketiga, dan menghindari menggunakan variabel tambahan (tertulis). Di bawah ini adalah bagaimana saya menggunakannya dengan beberapa perubahan. Saya dapat beralih untuk memperluas fungsi vektor dan / atau va_arg di masa depan.

// Based on answer by "Viktor Sehr" on Stack Overflow
// https://stackoverflow.com/a/8907356
//
template <typename T>
class mkvec {
public:
    typedef mkvec<T> my_type;
    my_type& operator<< (const T& val) {
        data_.push_back(val);
        return *this;
    }
    my_type& operator<< (const std::vector<T>& inVector) {
        this->data_.reserve(this->data_.size() + inVector.size());
        this->data_.insert(this->data_.end(), inVector.begin(), inVector.end());
        return *this;
    }
    operator std::vector<T>() const {
        return data_;
    }
private:
    std::vector<T> data_;
};

std::vector<int32_t>    vec1;
std::vector<int32_t>    vec2;

vec1 = mkvec<int32_t>() << 5 << 8 << 19 << 79;  
// vec1 = (5,8,19,79)
vec2 = mkvec<int32_t>() << 1 << 2 << 3 << vec1 << 10 << 11 << 12;  
// vec2 = (1,2,3,5,8,19,79,10,11,12)

Metode di bawah ini dapat digunakan untuk menginisialisasi vektor dalam c ++.

1. int arr[] = {1, 3, 5, 6}; vector<int> v(arr, arr + sizeof(arr)/sizeof(arr[0]));

2. vector<int>v; v.push_back(1); v.push_back(2); v.push_back(3); dan seterusnya

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

Yang ketiga hanya diizinkan di C ++ 11 dan seterusnya.

Ada banyak jawaban bagus di sini, tetapi karena saya secara mandiri tiba di saya sendiri sebelum membaca ini, saya pikir saya akan melemparkan milik saya di sini ...

Berikut adalah metode yang saya gunakan untuk ini yang akan bekerja secara universal di seluruh kompiler dan platform:

Buat struct atau kelas sebagai wadah untuk koleksi objek Anda. Tetapkan fungsi kelebihan operator untuk <<.

class MyObject;

struct MyObjectList
{
    std::list<MyObject> objects;
    MyObjectList& operator<<( const MyObject o )
    { 
        objects.push_back( o );
        return *this; 
    }
};

Anda dapat membuat fungsi yang menggunakan struct Anda sebagai parameter, misalnya:

someFunc( MyObjectList &objects );

Kemudian, Anda dapat memanggil fungsi itu, seperti ini:

someFunc( MyObjectList() << MyObject(1) <<  MyObject(2) <<  MyObject(3) );

Dengan begitu, Anda dapat membangun dan meneruskan koleksi objek berukuran dinamis ke fungsi dalam satu baris bersih!

Jika Anda menginginkan sesuatu dengan urutan umum yang sama dengan Boost :: assign tanpa membuat dependensi pada Boost, berikut ini setidaknya secara samar-samar serupa:

template<class T>
class make_vector {
    std::vector<T> data;
public:
    make_vector(T const &val) { 
        data.push_back(val);
    }

    make_vector<T> &operator,(T const &t) {
        data.push_back(t);
        return *this;
    }

    operator std::vector<T>() { return data; }
};

template<class T> 
make_vector<T> makeVect(T const &t) { 
    return make_vector<T>(t);
}

Meskipun saya berharap sintaks untuk menggunakannya lebih bersih, itu masih tidak terlalu buruk:

std::vector<int> x = (makeVect(1), 2, 3, 4);

typedef std::vector<int> arr;

arr a {10, 20, 30};       // This would be how you initialize while defining

Untuk mengkompilasi penggunaan:

clang++ -std=c++11 -stdlib=libc++  <filename.cpp>

// Before C++11
// I used following methods:

// 1.
int A[] = {10, 20, 30};                              // original array A

unsigned sizeOfA = sizeof(A)/sizeof(A[0]);           // calculate the number of elements

                                                     // declare vector vArrayA,
std::vector<int> vArrayA(sizeOfA);                   // make room for all
                                                     // array A integers
                                                     // and initialize them to 0 

for(unsigned i=0; i<sizeOfA; i++)
    vArrayA[i] = A[i];                               // initialize vector vArrayA


//2.
int B[] = {40, 50, 60, 70};                          // original array B

std::vector<int> vArrayB;                            // declare vector vArrayB
for (unsigned i=0; i<sizeof(B)/sizeof(B[0]); i++)
    vArrayB.push_back(B[i]);                         // initialize vArrayB

//3.
int C[] = {1, 2, 3, 4};                              // original array C

std::vector<int> vArrayC;                            // create an empty vector vArrayC
vArrayC.resize(sizeof(C)/sizeof(C[0]));              // enlarging the number of 
                                                     // contained elements
for (unsigned i=0; i<sizeof(C)/sizeof(C[0]); i++)
     vArrayC.at(i) = C[i];                           // initialize vArrayC


// A Note:
// Above methods will work well for complex arrays
// with structures as its elements.

Jika arraynya adalah:

int arr[] = {1, 2, 3};
int len = (sizeof(arr)/sizeof(arr[0])); // finding length of array
vector < int > v;
std:: v.assign(arr, arr+len); // assigning elements from array to vector 

Sangat mudah untuk membuat inline vektor tanpa mendefinisikan variabel saat menulis tes, misalnya:

assert(MyFunction() == std::vector<int>{1, 3, 4}); // <- this.

Terkait, Anda dapat menggunakan yang berikut ini jika Anda ingin memiliki vektor yang benar-benar siap untuk masuk dalam pernyataan cepat (misalnya segera beralih ke fungsi lain):

#define VECTOR(first,...) \
   ([](){ \
   static const decltype(first) arr[] = { first,__VA_ARGS__ }; \
   std::vector<decltype(first)> ret(arr, arr + sizeof(arr) / sizeof(*arr)); \
   return ret;})()

contoh fungsi

template<typename T>
void test(std::vector<T>& values)
{
    for(T value : values)
        std::cout<<value<<std::endl;
}

contoh penggunaan

test(VECTOR(1.2f,2,3,4,5,6));

meskipun hati-hati tentang jenis deklarasi, pastikan nilai pertama jelas apa yang Anda inginkan.

Ada berbagai cara untuk meng-hardcode suatu vektor, saya akan membagikan beberapa cara:

1. Inisialisasi dengan mendorong nilai satu per satu

// Create an empty vector 
    vector<int> vect;  

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

2. Inisialisasi seperti array

vector<int> vect{ 10, 20, 30 };

3. Inisialisasi dari sebuah array

    int arr[] = { 10, 20, 30 }; 
    int n = sizeof(arr) / sizeof(arr[0]); 

    vector<int> vect(arr, arr + n); 

4. Inisialisasi dari vektor lain

    vector<int> vect1{ 10, 20, 30 }; 

    vector<int> vect2(vect1.begin(), vect1.end()); 

"Bagaimana cara membuat vektor STL dan menginisialisasi seperti di atas? Apa cara terbaik untuk melakukannya dengan upaya mengetik minimum?"

Cara termudah untuk menginisialisasi vektor saat Anda menginisialisasi larik bawaan Anda menggunakan daftar penginisialisasi yang diperkenalkan di C ++ 11 .

// Initializing a vector that holds 2 elements of type int.
Initializing:
std::vector<int> ivec = {10, 20};


// The push_back function is more of a form of assignment with the exception of course
//that it doesn't obliterate the value of the object it's being called on.
Assigning
ivec.push_back(30);

ivec adalah 3 elemen dalam ukuran setelah Penugasan (pernyataan berlabel) dieksekusi.

B. Stroustrup menjelaskan cara yang bagus untuk melakukan operasi rantai di 16.2.10 Selfreference pada halaman 464 dalam edisi C ++ 11 dari Prog. Lang. di mana fungsi mengembalikan referensi, di sini diubah menjadi vektor. Dengan cara ini Anda dapat rantai seperti v.pb(1).pb(2).pb(3);tetapi mungkin terlalu banyak bekerja untuk keuntungan kecil.

#include <iostream>
#include <vector>

template<typename T>
class chain
{
private:
    std::vector<T> _v;
public:
    chain& pb(T a) {
        _v.push_back(a);
        return *this;
    };
    std::vector<T> get() { return _v; };
};

using namespace std;

int main(int argc, char const *argv[])
{
    chain<int> v{};

    v.pb(1).pb(2).pb(3);

    for (auto& i : v.get()) {
        cout << i << endl;
    }

    return 0;
}

1
2
3

Cara paling sederhana, lebih ergonomis (dengan C ++ 11 atau lebih baru):

auto my_ints = {1,2,3};

Jika Anda ingin memilikinya di kelas Anda sendiri:

#include <initializer_list>
Vector<Type>::Vector(std::initializer_list<Type> init_list) : _size(init_list.size()),
_capacity(_size),
_data(new Type[_size])
{
    int idx = 0;
    for (auto it = init_list.begin(); it != init_list.end(); ++it)
        _data[idx++] = *it;
}