Bagaimana Anda menyalin konten array ke std :: vector di C ++ tanpa perulangan?

Saya memiliki larik nilai yang diteruskan ke fungsi saya dari bagian lain dari program yang perlu saya simpan untuk diproses nanti. Karena saya tidak tahu berapa kali fungsi saya akan dipanggil sebelum waktunya untuk memproses data, saya memerlukan struktur penyimpanan dinamis, jadi saya memilih file std::vector. Saya tidak ingin melakukan loop standar ke push_backsemua nilai secara individual, alangkah baiknya jika saya dapat menyalin semuanya menggunakan sesuatu yang mirip dengan memcpy.

Jika Anda dapat membuat vektor setelah mendapatkan ukuran larik dan larik, Anda cukup mengatakan:

std::vector<ValueType> vec(a, a + n);

... dengan asumsi aadalah array Anda dan nmerupakan jumlah elemen yang dikandungnya. Jika tidak, std::copy()w / resize()akan melakukan trik.

Saya akan menjauh memcpy()kecuali Anda dapat yakin bahwa nilainya adalah tipe data biasa-lama (POD).

Juga, perlu dicatat bahwa tidak ada yang benar-benar menghindari perulangan for - ini hanya pertanyaan apakah Anda harus melihatnya di kode Anda atau tidak. Kinerja runtime O (n) tidak dapat dihindari untuk menyalin nilai.

Terakhir, perhatikan bahwa array gaya-C adalah container yang benar-benar valid untuk sebagian besar algoritme STL - pointer mentahnya setara dengan begin(), dan ( ptr + n) setara dengan end().

Ada banyak jawaban di sini dan hampir semuanya akan menyelesaikan pekerjaan.

Namun ada beberapa nasihat yang menyesatkan!

Berikut opsinya:

vector<int> dataVec;

int dataArray[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
unsigned dataArraySize = sizeof(dataArray) / sizeof(int);

// Method 1: Copy the array to the vector using back_inserter.
{
    copy(&dataArray[0], &dataArray[dataArraySize], back_inserter(dataVec));
}

// Method 2: Same as 1 but pre-extend the vector by the size of the array using reserve
{
    dataVec.reserve(dataVec.size() + dataArraySize);
    copy(&dataArray[0], &dataArray[dataArraySize], back_inserter(dataVec));
}

// Method 3: Memcpy
{
    dataVec.resize(dataVec.size() + dataArraySize);
    memcpy(&dataVec[dataVec.size() - dataArraySize], &dataArray[0], dataArraySize * sizeof(int));
}

// Method 4: vector::insert
{
    dataVec.insert(dataVec.end(), &dataArray[0], &dataArray[dataArraySize]);
}

// Method 5: vector + vector
{
    vector<int> dataVec2(&dataArray[0], &dataArray[dataArraySize]);
    dataVec.insert(dataVec.end(), dataVec2.begin(), dataVec2.end());
}

Untuk mempersingkat cerita, Metode 4, menggunakan vector :: insert, adalah yang terbaik untuk skenario bsruth.

Berikut beberapa detail berdarah:

Metode 1 mungkin yang paling mudah dipahami. Cukup salin setiap elemen dari array dan dorong ke belakang vektor. Sayangnya, ini lambat. Karena ada loop (tersirat dengan fungsi copy), setiap elemen harus diperlakukan secara individual; tidak ada peningkatan kinerja yang dapat dibuat berdasarkan fakta bahwa kita mengetahui bahwa array dan vektor adalah blok yang berdekatan.

Metode 2 adalah peningkatan kinerja yang disarankan untuk Metode 1; cukup pra-pesan ukuran array sebelum menambahkannya. Untuk array besar, ini mungkin membantu. Namun saran terbaik di sini adalah jangan pernah menggunakan reserve kecuali profil menunjukkan Anda mungkin bisa mendapatkan peningkatan (atau Anda perlu memastikan iterator Anda tidak akan dibatalkan). Bjarne setuju . Kebetulan, saya menemukan bahwa metode ini melakukan paling lambat sebagian besar waktu meskipun aku berjuang untuk secara komprehensif menjelaskan mengapa hal itu teratur secara signifikan lebih lambat dari metode 1 ...

Metode 3 adalah solusi jadul - berikan beberapa C pada masalah ini! Bekerja dengan baik dan cepat untuk jenis POD. Dalam hal ini, pengubahan ukuran harus dipanggil karena memcpy bekerja di luar batas vektor dan tidak ada cara untuk memberi tahu vektor bahwa ukurannya telah berubah. Selain sebagai solusi yang jelek (penyalinan byte!), Ingatlah bahwa ini hanya dapat digunakan untuk jenis POD . Saya tidak akan pernah menggunakan solusi ini.

Metode 4 adalah cara terbaik untuk melakukannya. Artinya jelas, (biasanya) tercepat dan berfungsi untuk objek apa pun. Tidak ada kerugian menggunakan metode ini untuk aplikasi ini.

Metode 5 adalah tweak pada Metode 4 - salin array ke dalam vektor dan kemudian tambahkan. Pilihan bagus - umumnya cepat dan jelas.

Akhirnya, Anda sadar bahwa Anda dapat menggunakan vektor sebagai pengganti array, bukan? Bahkan ketika suatu fungsi mengharapkan array gaya-c Anda bisa menggunakan vektor:

vector<char> v(50); // Ensure there's enough space
strcpy(&v[0], "prefer vectors to c arrays");

Harapan yang membantu seseorang di luar sana!

Jika yang Anda lakukan hanyalah mengganti data yang ada, maka Anda bisa melakukan ini

std::vector<int> data; // evil global :)

void CopyData(int *newData, size_t count)
{
   data.assign(newData, newData + count);
}

std :: copy adalah apa yang Anda cari.

Karena saya hanya dapat mengedit jawaban saya sendiri, saya akan membuat jawaban gabungan dari jawaban lain atas pertanyaan saya. Terima kasih untuk semua yang menjawab.

Menggunakan std :: copy , ini masih berulang di latar belakang, tetapi Anda tidak perlu mengetikkan kodenya.

int foo(int* data, int size)
{
   static std::vector<int> my_data; //normally a class variable
   std::copy(data, data + size, std::back_inserter(my_data));
   return 0;
}

Menggunakan memcpy biasa . Ini mungkin paling baik digunakan untuk tipe data dasar (yaitu int) tetapi tidak untuk array struct atau class yang lebih kompleks.

vector<int> x(size);
memcpy(&x[0], source, size*sizeof(int));

hindari memcpy, kataku. Tidak ada alasan untuk mengacaukan operasi penunjuk kecuali Anda benar-benar harus melakukannya. Selain itu, ini hanya akan berfungsi untuk jenis POD (seperti int) tetapi akan gagal jika Anda berurusan dengan jenis yang memerlukan konstruksi.

int dataArray[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };//source

unsigned dataArraySize = sizeof(dataArray) / sizeof(int);

std::vector<int> myvector (dataArraySize );//target

std::copy ( myints, myints+dataArraySize , myvector.begin() );

//myvector now has 1,2,3,...10 :-)

Namun jawaban lain, karena orang tersebut berkata "Saya tidak tahu berapa kali fungsi saya akan dipanggil", Anda dapat menggunakan metode penyisipan vektor seperti itu untuk menambahkan array nilai ke akhir vektor:

vector<int> x;

void AddValues(int* values, size_t size)
{
   x.insert(x.end(), values, values+size);
}

Saya suka cara ini karena implementasi vektor harus dapat mengoptimalkan cara terbaik untuk memasukkan nilai berdasarkan tipe iterator dan tipe itu sendiri. Anda agak membalas penerapan stl.

Jika Anda perlu menjamin kecepatan tercepat dan Anda tahu tipe Anda adalah tipe POD maka saya akan merekomendasikan metode pengubahan ukuran dalam jawaban Thomas:

vector<int> x;

void AddValues(int* values, size_t size)
{
   size_t old_size(x.size());
   x.resize(old_size + size, 0);
   memcpy(&x[old_size], values, size * sizeof(int));
}

Selain metode yang disajikan di atas, Anda perlu memastikan bahwa Anda menggunakan std :: Vector.reserve (), std :: Vector.resize (), atau buat vektor ke ukuran, untuk memastikan vektor Anda memiliki cukup elemen itu untuk menyimpan data Anda. jika tidak, Anda akan merusak memori. Ini berlaku untuk std :: copy () atau memcpy ().

Ini adalah alasan untuk menggunakan vector.push_back (), Anda tidak bisa menulis melewati akhir vektor.

Dengan asumsi Anda tahu seberapa besar item dalam vektor adalah:

std::vector<int> myArray;
myArray.resize (item_count, 0);
memcpy (&myArray.front(), source, item_count * sizeof(int));

http://www.cppreference.com/wiki/stl/vector/start