PERFORMANCE DE DIFFÉRENTS CONTAINERS DE LA STL

Commentaire de CptPingu le 11/03/2011 19:41:53 administrateur CS

- Évite les "using namespace", voir: [url=http://0217021.free.fr/portfolio/axel.berardino/articles/bon-usage-using-namespace]http://0217021.free.fr/portfolio/axel.berardino/articles/bon-usage-using-namespace[/url]
- Évite les void*, ça n'a rien à faire en C++. Tu peux les éviter avec de l'héritage ou des templates.
- Évite les variables globales
- En C++, on utilise un namespace anonyme et non plus le mot clé "static".
- clock n'est pas très précis

Je te propose une version pure C++:

#ifndef SCOPEELAPSEDTIME_HH_
# define SCOPEELAPSEDTIME_HH_

# include <iostream>
# include <sstream>
# include <ctime>
# include <sys/time.h>

class ScopeElapsedTime
{
public:
  ScopeElapsedTime()
    : origin_("")
  {
    gettimeofday(&begin_, &tz_);
  }

  ScopeElapsedTime(const std::string& origin)
    : origin_(origin)
  {
    gettimeofday(&begin_, &tz_);
  }

  ~ScopeElapsedTime()
  {
    std::ostringstream buff;
    gettimeofday(&end_, &tz_);
    long time = (end_.tv_sec - begin_.tv_sec) *
      1000000L + (end_.tv_usec - begin_.tv_usec);
    if (!origin_.empty())
      buff << "[" << origin_ << "]";
    buff << "Elapsed time: " << time << " us";

    std::cout << buff.str() << std::endl;
  }

private:
  std::string origin_;
  struct timeval begin_, end_;
  struct timezone tz_;
};

#endif /* !SCOPEELAPSEDTIME_HH_ */

#include <iostream>
#include <vector>
#include <list>
#include <queue>
#include <stack>

namespace
{
  template <typename Container, typename Type>
  struct Func
  {
    typedef void (*pFunc) (Container& container, const Type& parameter);
  };

  template <typename Container, typename Type>
  void push(Container& container, const Type& parameter)
  {
    container.push_back(parameter);
  }

  template <typename Type>
  void push(std::queue<Type>& container, const Type& parameter)
  {
    container.push(parameter);
  }

  template <typename Type>
  void push(std::stack<Type>& container, const Type& parameter)
  {
    container.push(parameter);
  }

  template <typename Container, typename Type>
  void pop(Container& container, const Type&)
  {
    container.pop_back();
  }

  template <typename Type>
  void pop(std::queue<Type>& container, const Type&)
  {
    container.pop();
  }

  template <typename Type>
  void pop(std::stack<Type>& container, const Type&)
  {
    container.pop();
  }

  template <typename Container, typename Type>
  void wrapperShowFunctionDuration(Container& v, const Type& t, int nb_iteration,
   const std::string& name, typename Func<Container, Type>::pFunc func)
  {
    ScopeElapsedTime timer(name);
    for (int i = 0; i < nb_iteration; ++i)
      func(v, t);
  }

  template <typename Container, typename Type>
  void showFunctionDuration(Container& v, int nb_iteration, const std::string& name, typename Func<Container, Type>::pFunc func)
  {
    const Type t = Type();
    wrapperShowFunctionDuration(v, t, nb_iteration, name, func);
  }
}

int main()
{
  ScopeElapsedTime timer("Global");
  int nb_iteration = 0;
  std::cout << " Iteration times = ";
  std::cin >> nb_iteration;

  std::vector<int> v;
  std::list<int> l;
  std::queue<int> q;
  std::stack<int> s;

  showFunctionDuration<std::vector<int>, int>(v, nb_iteration, "Push Vector", push<std::vector<int>, int>);
  showFunctionDuration<std::list<int>, int>(l, nb_iteration, "Push List", push<std::list<int>, int>);
  showFunctionDuration<std::queue<int>, int>(q, nb_iteration, "Push Queue", push<int>);
  showFunctionDuration<std::stack<int>, int>(s, nb_iteration, "Push Stack", push<int>);

  showFunctionDuration<std::vector<int>, int>(v, nb_iteration, "Pop Vector", pop<std::vector<int>, int>);
  showFunctionDuration<std::list<int>, int>(l, nb_iteration, "Pop List", pop<std::list<int>, int>);
  showFunctionDuration<std::queue<int>, int>(q, nb_iteration, "Pop Queue", pop<int>);
  showFunctionDuration<std::stack<int>, int>(s, nb_iteration, "Pop Stack", pop<int>);

  return 0;
}