Mesures – Test 2.2

#include <algorithm>
#include <vector>
#include <iostream>
#include <iterator>
#include <chrono>
#include <random>
#include <string>
using namespace std;
using namespace std::chrono;
class Entite
{
   enum class Grade : char
   {
      NEOPHYTE, APPRENTI, ADEPTE, EXPERT, MAITRE
   };
   Grade grade_;
   string nom_;
public:
   Entite(const string &nom = "Joe Blo")
      : grade_(Grade::NEOPHYTE), nom_(nom)
   {
   }
   Grade grade() const noexcept
      { return grade_; }
   string nom() const
      { return nom_; }
   void renommer(const string &nom)
      { nom_ = nom; }
   bool promotion() noexcept
   {
      if (grade() == Grade::MAITRE)
         return false;
      grade_ = static_cast<Grade>(static_cast<char>(grade()) + 1);
      return true;
   }
   bool expert() const noexcept
      { return grade() >= Grade::EXPERT; }
   bool operator ==(const Entite &e) const
      { return grade() == e.grade() && nom() == e.nom(); }
   friend bool operator==(const Entite &e, const string &s)
      { return e.nom() == s; }
   friend bool operator==(const string &s, const Entite &e)
      { return s == e.nom(); }
};
template <class Itt>
   Itt trouver_entite_manuel(Itt debut, Itt fin, const string &s, system_clock::duration &temps)
   {
      auto avant = system_clock::now();
      for (; debut != fin; ++debut)
         if (*debut == s)
         {
            temps = system_clock::now() - avant;
            return debut;
         }
      temps = system_clock::now() - avant;
      return fin;
   }
template <class Itt>
   Itt trouver_entite_std(Itt debut, Itt fin, const string &s, system_clock::duration &temps)
   {
      auto avant = system_clock::now();
      auto itt = find(debut, fin, s);
      temps = system_clock::now() - avant;
      return itt;
   }
int main()
{
   const int N = 10000000;
   vector<Entite> v(N);
   v.front().renommer("Fred");
   random_device rd;
   mt19937 rng(rd());
   shuffle(begin(v), end(v), rng);
   {
      system_clock::duration t_man;
      auto itt = trouver_entite_manuel(begin(v), end(v), "Fred", t_man);
      cout << "Recherche manuelle sur " << N << " elements: position "
            << distance(itt, end(v)) << ", temps requis: "
            << duration_cast<milliseconds>(t_man).count() << endl;
   }
   {
      system_clock::duration t_std;
      auto itt = trouver_entite_std(begin(v), end(v), "Fred", t_std);
      cout << "Recherche standard sur " << N << " elements: position "
            << distance(itt, end(v)) << ", temps requis: "
            << duration_cast<milliseconds>(t_std).count() << endl;
   }
}

Sur mon petit ordinateur portatif, compilé avec Visual Studio 2013, configuration Release, et en prenant bien entendu soin d'ajouter _SECURE_SCL=0 aux options du préprocesseur pour désactiver les (franchement inutiles et nuisibles) Checked Iterators, j'obtiens :

Recherche manuelle sur 10000000 elements: position 9179547, temps requis: 24
Recherche standard sur 10000000 elements: position 9179547, temps requis: 24
Appuyez sur une touche pour continuer...

Valid XHTML 1.0 Transitional

CSS Valide !