Bir dizinin içeriğini döngü yapmadan C ++ 'da bir std :: vektörüne nasıl kopyalarsınız?

Daha sonraki işlemler için kaydetmem gereken programın farklı bir bölümünden işlevime aktarılan bir dizi değerim var. Verileri işleme zamanı gelmeden fonksiyonumun kaç kez çağrılacağını bilmediğim için dinamik bir depolama yapısına ihtiyacım var, bu yüzden bir std::vector. Standart döngüyü push_backtüm değerlere tek tek yapmak zorunda kalmak istemiyorum, hepsini benzer bir şey kullanarak kopyalayabilseydim güzel olurdu memcpy.

Dizi ve dizi boyutunu aldıktan sonra vektörü oluşturabilirseniz, şunu söyleyebilirsiniz:

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

... asizin diziniz ve niçerdiği elemanların sayısı olduğunu varsayar . Aksi takdirde, std::copy()ağırlık / resize()hile olacaktır.

memcpy()Değerlerin düz eski veri (POD) türleri olduğundan emin olmadığınız sürece uzak dururum.

Ayrıca, bunların hiçbirinin for döngüsünü gerçekten engellemediğini de belirtmek gerekir - bu sadece onu kodunuzda görmeniz gerekip gerekmediğiyle ilgili bir soru. O (n) çalışma zamanı performansı, değerleri kopyalamak için kaçınılmazdır.

Son olarak, C-stili dizilerin çoğu STL algoritması için mükemmel şekilde geçerli kaplar olduğunu unutmayın - ham işaretçi eşdeğerdir begin()ve ( ptr + n) ile eşdeğerdir end().

Burada birçok cevap var ve hemen hemen hepsi işi halledecek.

Ancak bazı yanıltıcı tavsiyeler var!

Seçenekler şunlardır:

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

Uzun lafın kısası Yöntem 4, vektör :: insert kullanmak, bsruth'un senaryosu için en iyisidir.

İşte bazı kanlı ayrıntılar:

Yöntem 1 muhtemelen anlaşılması en kolay olanıdır. Dizideki her bir öğeyi kopyalayın ve vektörün arkasına itin. Ne yazık ki, yavaş. Bir döngü olduğu için (kopyalama işleviyle ifade edilir), her öğe ayrı ayrı ele alınmalıdır; Dizi ve vektörlerin bitişik bloklar olduğunu bildiğimiz gerçeğine dayanarak hiçbir performans iyileştirmesi yapılamaz.

Yöntem 2 , Yöntem 1 için önerilen bir performans iyileştirmesidir; diziyi eklemeden önce boyutunu önceden ayırmanız yeterlidir. Büyük diziler için bu yardımcı olabilir . Bununla birlikte, buradaki en iyi tavsiye, profil oluşturma bir iyileştirme elde edebileceğinizi (veya yineleyicilerinizin geçersiz kılınmayacağından emin olmanız gerektiğini) önermedikçe, asla rezerv kullanmamaktır. Bjarne aynı fikirde . Bu arada, neden düzenli olarak yöntem 1'den önemli ölçüde daha yavaş olduğunu kapsamlı bir şekilde açıklamakta zorlansam da , bu yöntemin çoğu zaman en yavaş performans gösterdiğini buldum ...

Yöntem 3 eski okul çözümüdür - soruna biraz C at! POD türleri için iyi ve hızlı çalışır. Memcpy vektörün sınırları dışında çalıştığından ve bir vektöre boyutunun değiştiğini söylemenin bir yolu olmadığından bu durumda yeniden boyutlandırmanın çağrılması gerekir. Çirkin bir çözüm olmasının yanı sıra (bayt kopyalama!), Bunun yalnızca POD türleri için kullanılabileceğini unutmayın . Bu çözümü asla kullanmam.

Yöntem 4 , gitmenin en iyi yoludur. Anlamı açıktır, (genellikle) en hızlısıdır ve herhangi bir nesne için işe yarar. Bu uygulama için bu yöntemi kullanmanın bir dezavantajı yoktur.

Yöntem 5 , Yöntem 4'te yapılan bir düzeltmedir - diziyi bir vektöre kopyalayın ve ardından ekleyin. İyi seçenek - genellikle hızlı ve net.

Son olarak, diziler yerine vektörleri kullanabileceğinizi biliyorsunuz, değil mi? Bir işlev c-tarzı diziler beklediğinde bile vektörleri kullanabilirsiniz:

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

Umarım bu dışarıdaki birine yardımcı olur!

Tek yaptığınız mevcut verileri değiştirmekse, bunu yapabilirsiniz

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

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

std :: copy , aradığınız şey.

Sadece kendi cevabımı düzenleyebildiğim için soruma diğer cevaplardan bileşik bir cevap vereceğim. Cevaplayan hepinize teşekkürler.

Kullanılması std :: copy bu hala arka planda yinelediğinden ama kodunu yazmanız gerekmez.

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

Normal memcpy kullanma . Bu muhtemelen en iyi temel veri türleri (yani int) için kullanılır, ancak daha karmaşık yapı veya sınıf dizileri için kullanılmaz.

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

Memcpy'den kaçının diyorum. Gerçekten mecbur kalmadıkça işaretçi işlemleriyle uğraşmanıza gerek yok. Ayrıca, yalnızca POD türleri (int gibi) için çalışacak, ancak inşa gerektiren türlerle uğraşıyorsanız başarısız olacaktır.

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

Yine başka bir cevap, kişi "Benim fonksiyonumun kaç kez çağrılacağını bilmiyorum" dediğinden, değer dizilerini vektörün sonuna eklemek için vektör ekleme yöntemini kullanabilirsiniz:

vector<int> x;

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

Bu yolu seviyorum çünkü vektör uygulaması, yineleyici türüne ve türün kendisine bağlı olarak değerleri eklemek için en iyi yolu optimize edebilmelidir. Stl'nin uygulanmasına bir şekilde yanıt veriyorsunuz.

En yüksek hızı garanti etmeniz gerekiyorsa ve türünüzün bir POD türü olduğunu biliyorsanız, Thomas'ın cevabında yeniden boyutlandırma yöntemini öneririm:

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

Yukarıda sunulan yöntemlere ek olarak, vektörünüzün içinde yeterli öğe olduğundan emin olmak için std :: Vector.reserve (), std :: Vector.resize () kullandığınızdan veya vektörü boyut olarak oluşturduğunuzdan emin olmanız gerekir. verilerinizi tutmak için. değilse, hafızayı bozarsınız. Bu, std :: copy () veya memcpy () için geçerlidir.

Vector.push_back () kullanmanın nedeni budur, vektörün sonunu yazamazsınız.

Vektördeki öğenin ne kadar büyük olduğunu bildiğinizi varsayarsak:

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