Sorted vector vs set vs unordered set, C++ (vc++)

Language: Layout:

//Microsoft (R) C/C++ Optimizing Compiler Version 19.00.23506 for x86

#include <iostream>
#include <ctime>
#include <random>
#include <set>
#include <unordered_set>
#include <vector>
#include <algorithm>

std::vector<std::size_t> make_test_data( std::size_t n )
{
    std::mt19937 rng( std::time(nullptr) ) ;
    std::vector<std::size_t> result(n) ;
    for( auto& v : result ) v = rng() ;
    return result ;
}

void insert( const std::vector<std::size_t>& srce, std::vector<std::size_t>& dest )
{
    dest = srce ;
    std::sort( std::begin(dest), std::end(dest) ) ;
}

void insert( const std::vector<std::size_t>& srce, std::set<std::size_t>& dest )
{
    dest = { std::begin(srce), std::end(srce) } ;
}

void insert(const std::vector<std::size_t>& srce, std::unordered_set<std::size_t>& dest)
{
     dest = { std::begin(srce), std::end(srce) } ;
}

std::size_t find( const std::vector<std::size_t>& what, const std::vector<std::size_t>& vec )
{
    std::size_t n = 0 ;
    for( std::size_t v : what )
    {
        if(std::binary_search( std::begin(vec), std::end(vec), v ))
        {
            ++n;
        }
    }
    return n ;
}

std::size_t find( const std::vector<std::size_t>& what, const std::set<std::size_t>& set )
{
    std::size_t n = 0 ;
    for( std::size_t v : what ) if( set.find(v) != set.end() ) ++n ;
    return n ;
}

std::size_t find( const std::vector<std::size_t>& what, const std::unordered_set<std::size_t>& set )
{
    std::size_t n = 0 ;
    for( std::size_t v : what ) if( set.find(v) != set.end() ) ++n ;
    return n ;
}

struct timer
{
    const std::clock_t start = std::clock() ;
    ~timer()
    {
        const auto end = std::clock() ;
        const auto ms = (end-start) * 1000.0 / CLOCKS_PER_SEC ;
        std::cout << ms << " msecs.\n" << std::flush ;
    }
};

int main()
{
    constexpr std::size_t n_values = 1000000 ;
    constexpr std::size_t n_searches = 1'000'000 ;
    
    std::cout << n_values << " values, " << n_searches << " searches\n\n" ;
    
    const auto data_set = make_test_data(n_values) ;
    const auto searched_values = make_test_data(n_searches) ;

std::vector<std::size_t> vec ;
    std::set<std::size_t> set ;
    std::unordered_set<std::size_t>uset;
    
    volatile std::size_t x = 0 ;

{
        std::cout << "vector: insert & sort -  " ;
        timer t ;
        insert( data_set, vec ) ;
    }

{
        std::cout << "         vector: find -   " ;
        timer t ;
        x += find( searched_values, vec ) ;
    }

{
        std::cout << "\n          set: insert - " ;
        timer t ;
        insert( data_set, set ) ;
    }

{
        std::cout << "            set: find -   " ;
        timer t ;
        x += find( searched_values, set ) ;
    }
    
    {
        std::cout << "\n          unordered set: insert - " ;
        timer t ;
        insert( data_set, uset ) ;
    }

{
        std::cout << "            unordered set: find -   " ;
        timer t ;
        x += find( searched_values, uset ) ;
    }
    
    return x - x ;
}

Show compiler warnings [ + ] Compiler args [ + ] Show input
Compilation time: 2,67 sec, absolute running time: 5,15 sec, absolute service time: 7,83 sec