可以乱序插入向量吗？

Question

I want to insert vec1 by vec2 and vec3 . When I insert vec3 first, the program cannot exit successfully. But when I insert vec2 and then insert vec3 , the program can exit successfully. I want to know the failed reason.

Why insert vec1 Out of order : I want to insert it by two different threads( The two threads will write to different positions and do not affect each other.), so the order cannot be guaranteed.

#include <iostream>
#include <vector>
#include <chrono>

using namespace std::chrono;
using namespace std;


struct DocIdAndPayLoad
{

    uint64_t m_docId;

    DocIdAndPayLoad()
    {
        DefaultCnt++;
    }


    DocIdAndPayLoad(const DocIdAndPayLoad& /*_bond_rhs*/)
    {
        CopyCnt++;
    }


    DocIdAndPayLoad(DocIdAndPayLoad&& _bond_rhs)
    {
        MoveCnt++;
    }


    DocIdAndPayLoad& operator=(const DocIdAndPayLoad& _bond_rhs)
    {
        AssignCnt++;
        return *this;
    }


    static int DefaultCnt;
    static int CopyCnt;
    static int MoveCnt;
    static int AssignCnt;
};

int DocIdAndPayLoad::DefaultCnt = 0;
int DocIdAndPayLoad::CopyCnt = 0;
int DocIdAndPayLoad::MoveCnt = 0;
int DocIdAndPayLoad::AssignCnt = 0;

int main()
{
    const int hugeSize=10000;
    vector<DocIdAndPayLoad> vec1;
    cout<<vec1.size()<<" "<<vec1.capacity()<<endl;

    vector<DocIdAndPayLoad> vec2(hugeSize/2);
    vector<DocIdAndPayLoad> vec3(hugeSize/2);

    auto start1 = high_resolution_clock::now();
    vec1.reserve(hugeSize);
    
    //vec1.insert(vec1.begin()+hugeSize/2, std::make_move_iterator(vec3.begin()), std::make_move_iterator(vec3.end()));
    vec1.insert(vec1.begin(), std::make_move_iterator(vec2.begin()), std::make_move_iterator(vec2.end()));
    
    auto stop1 = high_resolution_clock::now();
    auto duration = duration_cast<microseconds>(stop1 - start1);
    cout << "Cost1: "<< duration.count() << " microseconds" << endl;

    vector<DocIdAndPayLoad> vec4;
    auto start2 = high_resolution_clock::now();
    vec4.resize(hugeSize);
    auto stop2 = high_resolution_clock::now();
    auto duration2 = duration_cast<microseconds>(stop2 - start2);
    cout << "Cost2: "<< duration2.count() << " microseconds" << endl;

    cout<<vec1.size()<<" "<<vec1.capacity()<<endl;
         
    return 0;
}

Answer 1

The reserve call sets the capacity of a vector, but not its size. That means the vector will still be empty after calling

vec1.reserve(hugeSize);

Any indexing in that vector will be out of bounds and lead to undefined behavior.

More importantly, since the vector is empty, vec1.begin() will return the end iterator (ie vec1.begin() == vec1.end() ), so vec1.begin()+hugeSize/2 is invalid! .

Attempting to dereference the end iterator (or beyond) leads to undefined behavior and possible crashes.