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


612

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?


1
jika Anda tidak akan mengubah ukuran int setelah inisialisasi, pertimbangkan untuk menggunakan tr1 array.
zr.

@ zr, Anda punya saya ingin tahu ... jika saya membutuhkan ukuran tetap, tidak bisakah saya menggunakan array tua biasa sendiri? Melihat array tr1 sekarang ...
Agnel Kurian

2
tr1::arrayberguna karena array biasa tidak menyediakan antarmuka wadah STL
Manuel

Mengubah judul untuk menjadikan ini pertanyaan C ++ 03 secara eksplisit. Tampaknya lebih mudah daripada melalui dan memperbaiki semua jawaban yang masuk akal dengan standar C ++ yang baru.
TED

Jawaban:


548

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

7
@Agnel Ini akan berfungsi dengan baik tanpa staticatau const, namun keduanya membuatnya lebih eksplisit tentang bagaimana ia harus digunakan dan memungkinkan kompiler untuk membuat optimasi tambahan.
Yacoby

68
Saya tidak menurunkan ini, tetapi saya tergoda. Terutama karena ini menghemat hampir tidak ada lebih dari hanya menggunakan array yang diinisialisasi di tempat pertama. Namun, itu benar-benar kesalahan C ++, bukan milik Anda.
TED

2
Bisakah Anda menjelaskan mengapa Anda menggunakan parameter tersebut saat mendefinisikan vektor vec.
DomX23

13
sizeof (array) adalah salah satu dari sedikit pengecualian yang memungkinkan untuk mendapatkan ukuran total elemen array dan BUKAN dimensi pointer arr. Jadi pada dasarnya dia menggunakan vektor (pointer_to_first_element, pointer_to_first_element + size_in_bytes_of_the_whole_array / size_of_one_element) yaitu: vector (pointer_to_first_element, pointer_after_final_element). Jenis sudah diberikan dengan <int>, sehingga vektor tahu berapa banyak satu elemen. Ingatlah bahwa iterator dapat diperlakukan sebagai pointer sehingga Anda pada dasarnya menggunakan konstruktor vektor (iterator begin, iterator end)
Johnny Pauling

11
@ TED: Terkadang Anda perlu memodifikasi vektor yang dihasilkan. Misalnya, Anda mungkin harus selalu memiliki beberapa parameter default dan terkadang menambahkan beberapa yang disesuaikan untuknya.
DarkWanderer

642

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.


Karena vektor berukuran sendiri, apakah tidak masalah untuk menginisialisasi sebagai kosong juga? Seperti di konstruktor this->vect = {};:?
Azurespot

3
@Azurespot Anda hanya dapat menginisialisasi, dan itu akan kosong:std::vector<T> vector;
Luke

2
Kalau-kalau ada orang yang penasaran std::vector<int> v = {1, 2, 3, 4};, vektor initializer list constructorakan dipanggil untuk inisialisasi semacam ini, dokumennya dapat ditemukan di C++ 11bagian ini .
simomo

103

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.


2
Dalam keadilan, ini awalnya pertanyaan C ++ 03, tapi saya harap orang / perusahaan mengadopsi standar baru. C ++ masih membutuhkan implementasi variabel-panjang array (VLA) di perpustakaan standar mirip dengan apa yang tersedia di Eigen dan Boost.
Adam Erickson

Sayangnya, dalam beberapa kasus pendekatan ini bermasalah misalnya open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1467 . Yuck.
Lightness Races dalam Orbit

Jika "daftar-inisialisasi agregat dari objek dengan tipe yang sama" adalah hal Anda, mungkin ada masalah yang lebih besar dalam basis kode Anda ... Saya tidak bisa memikirkan aplikasi mana pun yang akan membenarkan masalah debugging.
Adam Erickson

77

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

Tentu saja saya tidak downvote tapi saya punya pertanyaan: kapan ukuran array bukan konstanta waktu kompilasi? Yaitu, dalam kasus apa Anda akan menggunakan solusi pertama dalam cuplikan kedua Anda dan bukan yang ketiga?
Manuel

4
@ Manuel, ukuran array adalah bagian dari tipe, dan karenanya merupakan konstanta waktu kompilasi. Sekarang, opsi 1 menggunakan konstanta waktu kompilasi 'N' sebagai nilai kembali untuk suatu fungsi. Kembalinya suatu fungsi bukan waktu kompilasi, tetapi nilai runtime, bahkan jika itu mungkin akan menjadi inline sebagai nilai konstan di tempat panggilan. Perbedaannya adalah bahwa Anda tidak dapat melakukan:, int another[size_of_array(array)]selagi dapat melakukannya int another[ARRAY_SIZE(array)].
David Rodríguez - dribeas

1
Dalam opsi 3: Saya tidak benar-benar mengerti apa yang Anda maksud dengan "dinyatakan, tidak ditentukan"? Jadi variabel tidak akan mengambil memori tambahan?
To1ne

1
@ To1ne yang sebenarnya merupakan deklarasi fungsi, bukan variabel. Alasan untuk atau mendefinisikannya adalah bahwa kita sebenarnya tidak menginginkan fungsi untuk hal lain selain sizeofekspresi yang tidak memerlukan definisi. Meskipun Anda benar-benar dapat memberikan definisi, untuk melakukannya dengan benar akan membutuhkan alokasi statis array dan mengembalikan referensi ke sana, dan pertanyaan berikutnya adalah apa yang masuk akal sebagai nilai untuk array? (Perhatikan juga bahwa ini berarti satu array per jenis / ukuran kombinasi instantiations fungsi!) Karena tidak ada gunanya menggunakannya, saya lebih suka menghindarinya.
David Rodríguez - dribeas

1
@ mhd: Anda tidak dapat membuat array kosong dalam bahasa. 'int arr [0] = {};' bukan kode C ++ yang valid. Tetapi Anda benar bahwa jika Anda ingin menginisialisasi vektor kosong dan vektor tidak kosong Anda harus menggunakan konstruksi yang berbeda. Karena C ++ 11 ini bukan masalah karena Anda dapat menggunakan konstruktor daftar penginisialisasi
David Rodríguez - dribeas

61

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

2
C ++ 11 juga mendukung std::begindan std::enduntuk array, sehingga vektor juga dapat diinisialisasi seperti static const int arr[] = {10,20,30}; vector<int> vec(begin(arr), end(arr));.
Jaege

54

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.


1
Teknik ini juga dapat digunakan untuk membebani suatu fungsi untuk menerima array dengan ukuran yang diketik.
Andres Riofrio

4
Bisakah Anda menjelaskan const T (&data)[N]bagian itu? Bagaimana ukuran array dikurangi dalam panggilan Anda makeVector(values)?
Patryk

36

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};

28

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};

22

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.



16

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


14

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.


13

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;
}

1
Saya belum dapat menemukan cara menggunakan kode ini, tetapi terlihat menarik.
Daniel Buckmaster

Ini seperti salah satu komentar di atas. Hanya overloading + = dan operator koma. Menempatkan tanda kurung untuk kejelasan: ((((v+=1),2),3),4),5) Ini adalah cara kerjanya: Pertama, vector<T> += Tmengembalikan vector_inserter mari kita memanggilnya viyang merangkum vektor asli kemudian vi,Tmenambahkan T ke vektor asli yang vimerangkum dan mengembalikannya sendiri sehingga kita bisa melakukannya vi,Tlagi.
Piti Ongmongkolkul

kode ini tidak berfungsi dengan benar pada gcc 4.2.1 saya pikir karena mengembalikan referensi ke variabel lokal di dalam operator + = tetapi ide bagus. saya mengedit kode dan muncul satu lagi copy constructor. flow sekarang -> + = -> ctor -> koma -> copy -> dtor -> koma ...... -> koma -> dtor.
Yevhen

Saya mungkin kelebihan beban << bukannya + =. Setidaknya << sudah memiliki aturan efek samping yang tidak jelas karena perubahan bit dan
mode

11

Dalam C ++ 11:

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

21
Jika Anda sudah menggunakan C ++ 11, Anda sebaiknya menggunakan pendekatan langsung - vector<int> arr = {10, 20, 30};.
Bernhard Barker

Sebenarnya saya punya int [] (beberapa lib C) dan ingin mendorong ke dalam vektor (C ++ lib). Jawaban ini membantu, sisanya tidak ;-)
Nebula

10

Anda dapat melakukannya menggunakan boost :: assign.

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

detail di sini


19
Saya belum pernah melihat kasus yang lebih buruk dari penyalahgunaan operator dalam waktu yang lama. Apakah +=ada tack pada 1,2,3,4 .. pada akhir nilai, atau apakah menambahkan 1 ke elemen 1, 2 ke elemen 2, 3 ke elemen 3 (seperti sintaks seperti ini seharusnya di MATLAB- seperti bahasa)
bobobobo

10

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)

7

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.


5

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!


4

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

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>

Status pertanyaan C ++ 03 (bukan 11)
Mike P

1
Saya pikir itu tidak menentukan 03 ketika saya menjawab ini. Tapi tidak ingat dengan sempurna. Namun, itu masih merupakan jawaban yang berguna bagi seseorang yang mencari solusi cepat.
shaveenk

4
// 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.

4

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 

4

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

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

3

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.


3

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); 
  1. Inisialisasi seperti array
vector<int> vect{ 10, 20, 30 };
  1. Inisialisasi dari sebuah array
    int arr[] = { 10, 20, 30 }; 
    int n = sizeof(arr) / sizeof(arr[0]); 

    vector<int> vect(arr, arr + n); 
  1. Inisialisasi dari vektor lain
    vector<int> vect1{ 10, 20, 30 }; 

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

2

"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.


Pada baris yang sama, saya mencoba menginisialisasi peta, std :: map <int, bool> catinfo = {{1, false}}; Tetapi kemudian dapatkan kesalahan kesalahan ini: di C ++ 98 'catinfo' harus diinisialisasi oleh konstruktor, bukan oleh '{...}'
pdk

2

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


Pustaka armadillo melakukan ini untuk inisialisasi matriks tetapi menggunakan << operator alih-alih fungsi bernama: arma.sourceforge.net/docs.html#element_initialisation
Agnel Kurian

0

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

auto my_ints = {1,2,3};

0

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;
}
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.