Perbandingan prestasi penyalinan kontena dan pemindahan dalam perpustakaan kontena C++

Pergerakan kontena lebih pantas daripada menyalin, kerana pergerakan mengelakkan penyalinan elemen dan secara langsung memindahkan pemilikan elemen. Untuk bekas besar, mengalihkan bekas boleh meningkatkan prestasi dengan ketara.

Perbandingan prestasi salinan kontena dan bergerak dalam perpustakaan kontena C++

Dalam C++, salinan kontena dan pindah ialah dua operasi yang digunakan untuk menyalin kandungan kontena. Memahami perbezaan dan perbezaan prestasi antara kedua-duanya adalah penting untuk mengoptimumkan kod anda.

Menyalin Bekas

Menyalin bekas mencipta salinan baharu bekas yang mengandungi salinan semua elemen dalam bekas asal. Operasi ini melibatkan melaksanakan salinan mendalam bagi setiap elemen, yang boleh menjadi proses yang memakan masa.

std::vector<int> vec1 = {1, 2, 3};
std::vector<int> vec2(vec1); // 拷贝 vec1

Bekas Bergerak

Bekas memindahkan "memindahkan" kandungan bekas asal ke dalam bekas baharu dan bukannya membuat salinan. Ini adalah operasi yang lebih ringan kerana ia memindahkan pemilikan elemen secara langsung dari satu bekas ke bekas yang lain tanpa melakukan sebarang salinan.

std::vector<int> vec1 = {1, 2, 3};
std::vector<int> vec2 = std::move(vec1); // 移动 vec1

Perbandingan prestasi

Prestasi overhed salinan kontena adalah lebih tinggi daripada pergerakan kerana yang terakhir mengelakkan langkah penyalinan elemen. Untuk bekas besar, mengalihkan bekas boleh meningkatkan prestasi dengan ketara.

Kod berikut menunjukkan perbandingan masa salinan dan pemindahan untuk jenis bekas yang berbeza pada saiz elemen yang berbeza:

#include <ctime>
#include <vector>
#include <list>

int main()
{
    const int iterations = 100000;

    for (int size = 10000; size <= 100000; size += 10000)
    {
        // 创建容器
        std::vector<int> vec(size);
        std::list<int> list(size);

        // 记录拷贝时间
        std::clock_t start = std::clock();
        for (int i = 0; i < iterations; i++)
        {
            std::vector<int> vecCopy(vec);
        }
        std::clock_t end = std::clock();
        std::cout << "Vector copy: " << (double)(end - start) / CLOCKS_PER_SEC << "s" << std::endl;

        start = std::clock();
        for (int i = 0; i < iterations; i++)
        {
            std::list<int> listCopy(list);
        }
        end = std::clock();
        std::cout << "List copy: " << (double)(end - start) / CLOCKS_PER_SEC << "s" << std::endl;

        // 记录移动时间
        start = std::clock();
        for (int i = 0; i < iterations; i++)
        {
            std::vector<int> vecMove(std::move(vec));
        }
        end = std::clock();
        std::cout << "Vector move: " << (double)(end - start) / CLOCKS_PER_SEC << "s" << std::endl;

        start = std::clock();
        for (int i = 0; i < iterations; i++)
        {
            std::list<int> listMove(std::move(list));
        }
        end = std::clock();
        std::cout << "List move: " << (double)(end - start) / CLOCKS_PER_SEC << "s" << std::endl << std::endl;
    }

    return 0;
}

Output (contoh, keputusan sebenar mungkin berbeza dari sistem ke sistem):

Vector copy: 0.052s
List copy: 0.009s

Vector move: 0.014s
List move: 0.003s

...

Vector copy: 0.542s
List copy: 0.058s

Vector move: 0.082s
List move: 0.013s

Seperti yang ditunjukkan oleh output, untuk semua saiz Elemen, bekas bergerak adalah lebih pantas daripada bekas penyalinan.

Kesimpulan

Untuk bekas besar, mengalihkan bekas adalah pilihan pertama untuk menyalin bekas apabila bekas asal tidak diperlukan. Dengan memahami perbezaan antara penyalinan kontena dan pemindahan, anda boleh membuat keputusan termaklum dan mengoptimumkan prestasi kod anda.

Atas ialah kandungan terperinci Perbandingan prestasi penyalinan kontena dan pemindahan dalam perpustakaan kontena C++. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!