Performance comparison of container copying and moving in C++ container libraries

Container movement is faster than copying, because movement avoids element copying and directly transfers element ownership. For large containers, moving the container can significantly improve performance.

Performance comparison of container copy and move in C++ container library

In C++, container copy and move are two types of functions. For copying the contents of a container. Understanding the differences and performance differences between the two is critical to optimizing your code.

Copy Container

Copying a container creates a new copy of the container that contains copies of all the elements in the original container. This operation involves performing a deep copy of each element, which can be a time-consuming process.

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

Moving Containers

Container moves "move" the contents of the original container into the new container rather than creating a copy. This is a more lightweight operation because it directly transfers element ownership from one container to another without performing any copy.

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

Performance comparison

The performance overhead of container copy is higher than that of move, because the latter avoids the element copy step. For large containers, moving the container can significantly improve performance.

The following code shows the comparison of copy and move times of different container types at different element sizes:

#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 (Example, actual results may vary depending on the system ):

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

As the output shows, moving the container is much faster than copying it for all element sizes.

Conclusion

For large containers, moving the container is the first choice for copying the container when the original container is not needed. By understanding the differences between container copies and moves, you can make informed decisions and optimize the performance of your code.

The above is the detailed content of Performance comparison of container copying and moving in C++ container libraries. For more information, please follow other related articles on the PHP Chinese website!