Benchmark for-range vs std::generate

x.cpp

#include <celero/Celero.h>
#include <algorithm>
#include <numeric>
#include <vector>
#include <random>

CELERO_MAIN;

std::random_device rd;
std::mt19937 random_number_generator(rd());
std::uniform_real_distribution<double> rnd;

std::vector<double> fillVectorRandomlyFor(std::size_t const vector_size)
{
    std::vector<double> x(vector_size);

    for (auto& value : x)
        value = rnd(random_number_generator);

    return x;
}

std::vector<double> fillVectorRandomlyGenerate(std::size_t const vector_size)
{
    std::vector<double> x(vector_size);

    std::generate(std::begin(x), std::end(x),
                  [&]() { return rnd(random_number_generator); });

    return x;
}
std::vector<double> fillVectorZeroFor(std::size_t const vector_size)
{
    std::vector<double> x(vector_size);

    for (auto& value : x)
        value = 0;

    return x;
}

std::vector<double> fillVectorZeroGenerate(std::size_t const vector_size)
{
    std::vector<double> x(vector_size);

    std::generate(std::begin(x), std::end(x), [&]() { return 0; });

    return x;
}

std::vector<double> createVector(std::size_t const vector_size)
{
    std::vector<double> x(vector_size);

    return x;
}

std::vector<double> fillVectorIota(std::size_t const vector_size)
{
    std::vector<double> x(vector_size);

    std::iota(std::begin(x), std::end(x), 0);
    return x;
}

std::vector<double> exerciseRandomGenerator(std::size_t const vector_size)
{
    std::vector<double> x(vector_size);

    int const size = x.size();
    for (int i = 0; i < size; ++i)
        rnd(random_number_generator);

    return x;
}

BASELINE(A, Create, 30, 10000)
{
    celero::DoNotOptimizeAway(createVector(100000));
}

BENCHMARK(A, fillIota, 30, 10000)
{
    celero::DoNotOptimizeAway(fillVectorIota(100000));
}

BENCHMARK(A, fillZFor, 30, 10000)
{
    celero::DoNotOptimizeAway(fillVectorZeroFor(100000));
}

BENCHMARK(A, fillZGen, 30, 10000)
{
    celero::DoNotOptimizeAway(fillVectorZeroGenerate(100000));
}

BENCHMARK(A, exerciseRNG, 30, 1000)
{
    celero::DoNotOptimizeAway(exerciseRandomGenerator(100000));
}

BENCHMARK(A, fillFor, 30, 1000)
{
    celero::DoNotOptimizeAway(fillVectorRandomlyFor(100000));
}

BENCHMARK(A, fillGenerate, 30, 1000)
{
    celero::DoNotOptimizeAway(fillVectorRandomlyGenerate(100000));
}

Needs Celero https://github.com/DigitalInBlue/Celero
Compile with

g++ --std=c++14 -O3 -fopenmp -march=native -o x x.cpp -ICelero/include -LCeleroBuild -lcelero

running yields

Celero
Timer resolution: 0.001000 us
-----------------------------------------------------------------------------------------------------------------------------------------------
     Group      |   Experiment    |   Prob. Space   |     Samples     |   Iterations    |    Baseline     |  us/Iteration   | Iterations/sec  | 
-----------------------------------------------------------------------------------------------------------------------------------------------
A               | Create          |            Null |              30 |            1000 |         1.00000 |        25.28100 |        39555.40 | 
A               | fillIota        |            Null |              30 |            1000 |         2.22167 |        56.16600 |        17804.37 | 
A               | fillZFor        |            Null |              30 |            1000 |         1.95649 |        49.46200 |        20217.54 | 
A               | fillZGen        |            Null |              30 |            1000 |         1.94846 |        49.25900 |        20300.86 | 
A               | exerciseRNG     |            Null |              30 |            1000 |        31.93750 |       807.41200 |         1238.53 | 
A               | fillFor         |            Null |              30 |            1000 |        32.06792 |       810.70900 |         1233.49 | 
A               | fillGenerate    |            Null |              30 |            1000 |        32.06685 |       810.68200 |         1233.53 | 
Complete.