Mesures – Test 1.3

#include <algorithm>
#include <vector>
#include <list>
#include <deque>
#include <iostream>
#include <chrono>
#include <random>
#include <memory>
using namespace std;
using namespace std::chrono;
template <class F, class ... Args>
   auto test(F f, Args &&... args) {
      auto pre = high_resolution_clock::now();
      auto res = f(std::forward<Args>(args)...);
      auto post = high_resolution_clock::now();
      return pair{ res, post - pre };
   }
struct Sommation {
   long valeur;
   Sommation(long init) : valeur{ init } {
   }
   void operator()(int n) noexcept {
      valeur += n;
   }
};
template <class It, class T>
   auto somme_elements(It debut, It fin) {
      return for_each(debut, fin, Sommation{ 0L }).valeur;
   }
int main() {
   clog.rdbuf(nullptr); // trou noir
   enum { N = 10'000'000 };
   unique_ptr<int[]> tab{ new int[N] };
   mt19937 rng{ random_device{}() };
   uniform_int_distribution<int> distrib{ 1,10 };
   generate(&tab[0], &tab[N], [&]{ return distrib(rng); });
   auto [r0, dt0] = test([&tab] {
      return somme_elements(&tab[0], &tab[N]);
   });
   auto [r1, dt1] = test([v = vector<int>(&tab[0], &tab[N])] {
      return somme_elements(begin(v), end(v));
   });
   auto [r2, dt2] = test([lst = list<int>(&tab[0], &tab[N])] {
      return somme_elements(begin(lst), end(lst));
   });
   auto [r3, dt3] = test([d = deque<int>(&tab[0], &tab[N])] {
      return somme_elements(begin(d), end(d));
   });
   cout << "Resultats pour la somme de " << N << " elements (ms):" << endl
        << "\ttableau: " << duration_cast<milliseconds>(dt0).count() << " ms.\n"
        << "\tvector: " << duration_cast<milliseconds>(dt1).count() << " ms.\n"
        << "\tlist: " << duration_cast<milliseconds>(dt2).count() << " ms.\n"
        << "\tdeque: " << duration_cast<milliseconds>(dt3).count() << " ms." << endl;
   clog << r0 << ' ' << r1 << ' ' << r2 << ' ' << r3;
}

Resultats pour la somme de 10000000 elements (ms):
	tableau: 38 ms.
	vector: 38 ms.
	list: 579 ms.
	deque: 41 ms.

Resultats pour la somme de 10000000 elements (ms):
	tableau: 10 ms.
	vector: 10 ms.
	list: 74 ms.
	deque: 12 ms.

Resultats pour la somme de 10000000 elements (ms):
        tableau: 2 ms.
        vector: 2 ms.
        list: 38 ms.
        deque: 14 ms.