C++容器工作效率-内存操作

在之前轨迹的中看到了一段代码：

TrajectoryAnalyzer（）类中一个 构造函数，函数接收的是轨迹信息。在个构造函数中使用std::vector管理轨迹点，其实是逐个轨迹点push_back。

同时又看了一地段Eigen的代码，同样使用了std:vector，但是使用了自己内存分配器：

template>

class vector: protect _Vector_base

同样的vector使用默认的或者用户实现的分配器件在性能上有什么区别？vector的表现又是如何？

先看一段测试程序：

#include 
#include 
#include "time.hpp"
 
struct Point
{
        Point() = default;
        Point(double x_,double y_,double z_,double h_,double v_)
        {
                //std::cout<<"Create Point with params : "<
                x = x_;
                y = y_;
                z = z_;
                heading = h_;
                v = v_;
        }
 
        double x;
        double y;
        double z;
        double heading;
        double v;
};
 
 
template<typename T>
struct MyAllocator {
        using value_type = T;
 
        MyAllocator() noexcept {}
 
        template<typename U>
        MyAllocator(const MyAllocator&) noexcept {}
 
        template<class... Args>
        void construct(T* p, Args&&... args)
        {
                //std::cout << "Constructing one at "<< p <
                ::new(p) T(std::forward(args)...);
        };
 
        T* allocate(std::size_t n) {
                std::cout<<"Try to allocate "<<sizeof(T)*n<<" bytes"<
                if (n > std::size_t(-1) / sizeof(T)) {
                        throw std::bad_alloc();
                }
                if (auto p = static_cast(std::malloc(n * sizeof(T)))) {
                        return p;
                }
                throw std::bad_alloc();
        }
 
        void deallocate(T* p, std::size_t) noexcept {
                std::cout<<"Release all the region"<
                std::free(p);
        }
};
 
template <typename T, typename Allocator = MyAllocator>
using MyVector = std::vector;
 
int main() {
 
        MyVector myVector;
        myVector.reserve(1024);
 
        std::cout<<"Try to push 1024 elements "<
 
        std::cout<Now()<
        for(int elem = 0;elem < 1024;elem++)
                myVector.emplace_back(Point(1.0,2.0,3.0,4.0,5.0));
        std::cout<Now()<
 
        //test last vector elem
        std::cout << myVector[1020].x<
        std::cout << myVector[1020].y<
        std::cout << myVector[1020].z<
        std::cout << myVector[1020].heading<
        std::cout << myVector[1020].v<
 
        std::vector v;
        v.reserve(1024);
 
        std::cout<Now()<
        for(int elem = 0;elem < 1024;elem++)
                v.emplace_back(Point(1.0,2.0,3.0,4.0,5.0));
                //v.push_back(Point(1.0,2.0,3.0,4.0,5.0));
        std::cout<Now()<
 
        return 0;
}

Try to allocate 40960 bytes
Try to push 1024 elements
2023-09-15 16:05:39.879776909
2023-09-15 16:05:39.879906062
1
2
3
4
5
2023-09-15 16:05:39.879963790
2023-09-15 16:05:39.880002639
 
12953 ns
38849 ns

2023-09-15 16:46:17.482801219
2023-09-15 16:46:17.482927142
1
2
3
4
5
2023-09-15 16:46:17.482970918
2023-09-15 16:46:17.483009799
 
 
125923 ns
38881  ns