set.find vs find(vector)

#include <set>
#include <vector>
#include <iostream>
#include <string>
#include <ctime>
#include <random>
#include <sstream>
#include <algorithm>
#include <map>
#include <functional>

using namespace std;

#define ROLL_NUM 1000
#define RANGE_MAX (RangeType(-1)>>10)
typedef uint32_t RangeType;

class CompareFind {
private:
    /*compared STL*/
    set<string> sets;
    vector<string> vectors;

    /*store STL private function*/
    map<string, function<void(RangeType)>> functions;

    /*define random engine to run random test*/
    std::default_random_engine dre;
    // /*save random engine state before generating*/
    // std::stringstream engineState;
    std::vector<RangeType> randArray;

    /*time stamp*/
    clock_t time_start;
    clock_t time_end;

    void start_timer();
    void end_timer();
    void print_timer(string &s, RangeType elems);

public:
    CompareFind(){
        printf("%s constructor execute...\n", __func__);
        /*set random engine range*/
        std::uniform_int_distribution<RangeType> di(0, rangeMax);
        for(auto x=0; x<ROLL_NUM; x++)
            randArray.push_back(di(dre));

        functions.insert(make_pair(
            "sets insert",
            [=](RangeType i) {
                sets.insert(std::to_string(i));}));

        functions.insert(make_pair(
            "vectors insert",
            [=](RangeType i) {
                vectors.push_back(std::to_string(i));}));

        functions.insert(make_pair(
            "sets find",
            [=](RangeType i) {
                sets.find(to_string(randArray[i]));}));
        
        functions.insert(make_pair(
            "vectors find",
            [=](RangeType i) { 
                find(vectors.begin(),vectors.end(),to_string(randArray[i]));}));
    }
    RangeType rangeMax = RangeType(-1)>>10;
    void execute_each(string &&s, RangeType max);
};

void
CompareFind::start_timer() {
    time_start=clock();
}

void
CompareFind::end_timer() {
    time_end=clock();
}

void
CompareFind::print_timer(string &s, RangeType elems) {
    printf("%s %d elements using %f ms\n",
        s.c_str(), elems,
        1000*(time_end-time_start)/(double)CLOCKS_PER_SEC);
}

void
CompareFind::execute_each(string &&s, RangeType max) {
    start_timer();
    for (RangeType i = 0; i<max; i++)
        functions[s](i);
    end_timer();
    print_timer(s, rangeMax);
}


int main()
{
    CompareFind cf;
    cf.execute_each("sets insert", cf.rangeMax);
    cf.execute_each("vectors insert", cf.rangeMax);
    cf.execute_each("sets find", ROLL_NUM);
    cf.execute_each("vectors find", ROLL_NUM);
    return 0;
}

result is:
CompareFind constructor execute...
sets insert 4194303 elements using 5017.000000 ms
vectors insert 4194303 elements using 1174.000000 ms
sets find 4194303 elements using 3.000000 ms
vectors find 4194303 elements using 30505.000000 ms

conclusion is :
set using balance binary tree to strong elements, so set.insert cost more time but is easyer to find.