histogram with Forward Iterators

#include <stdio.h>

#include <algorithm>
#include <iterator>
#include <utility>
#include <vector>

template <typename InputIterator, typename LessThanComparator>
std::pair<typename std::iterator_traits<InputIterator>::value_type, int>
get_min_count(InputIterator b, InputIterator e, LessThanComparator comp) {
   typedef typename std::iterator_traits<InputIterator>::value_type vt;
   if (b == e) {
      return std::pair<vt, int>(vt(), 0);
   }
   vt minValue = *b;
   int count = 1;
   while (++b != e) {
      vt t = *b;
      if (comp(t, minValue)) {
         minValue = t;
         count = 1;
      } else if (!comp(minValue, t)) {
         ++count;
      }
   }
   return std::pair<vt, int>(minValue, count);
}


template <typename InputIterator>
std::pair<typename std::iterator_traits<InputIterator>::value_type, size_t>
get_min_count(InputIterator b, InputIterator e) {
   return get_min_count(b, e, std::less<typename std::iterator_traits<InputIterator>::value_type>());
}

template <typename T, typename ForwardIterator>
struct greaterThanFilterIterator {
   typedef typename std::iterator_traits<ForwardIterator>::value_type value_type;
   typedef typename std::iterator_traits<ForwardIterator>::difference_type difference_type;
   typedef typename std::iterator_traits<ForwardIterator>::iterator_category iterator_category;
   typedef typename std::iterator_traits<ForwardIterator>::pointer pointer;
   typedef typename std::iterator_traits<ForwardIterator>::reference reference;

   T oldMin;
   ForwardIterator b;
   ForwardIterator e;

   greaterThanFilterIterator(const T &minValue, ForwardIterator start, ForwardIterator end) : oldMin(minValue), b(start), e(end) {
      move();
   }

   greaterThanFilterIterator(ForwardIterator end) : e(end) { }

   greaterThanFilterIterator operator++() {
      ++b;
      move();
      return *this;
   }

   T &operator*() { return *b; }

   bool operator==(const greaterThanFilterIterator &rhs) const {
      return b == rhs.e;
   }

   bool operator!=(const greaterThanFilterIterator &rhs) const {
      return !(*this == rhs);
   }

private:
   void move() {
      while ((b != e) && (!(oldMin < *b))) { ++b; }
   }
};

template <class T, typename ForwardIterator>
struct greaterThanFilter {
   greaterThanFilterIterator<T, ForwardIterator> b_;
   greaterThanFilterIterator<T, ForwardIterator> e_;

   greaterThanFilter(const T &minValue, ForwardIterator b, ForwardIterator e) : b_(minValue, b, e), e_(e) { }

   greaterThanFilterIterator<T, ForwardIterator> begin() { return b_; }
   greaterThanFilterIterator<T, ForwardIterator> end() { return e_; }

   const greaterThanFilterIterator<T, ForwardIterator> begin() const { return b_; }
   const greaterThanFilterIterator<T, ForwardIterator> end() const { return e_; }
};




template <typename ForwardIterator, typename OutputIterator>
void
histogram(ForwardIterator b, ForwardIterator e, OutputIterator o) {
   typedef typename std::iterator_traits<ForwardIterator>::value_type vt;
   typedef typename std::iterator_traits<ForwardIterator>::difference_type dt;
   typedef typename std::pair<vt, dt> pairType;

   if (b == e) { return; }

   pairType p = get_min_count(b, e);
   do {
      *o++ = p;
      greaterThanFilter<vt, ForwardIterator> f(p.first, b, e);
      p = get_min_count(f.begin(), f.end());
   } while (p.second != 0);
}


int main(int argc, char *argv[]) {
   std::vector<int> values;
   for (int i = 1; i < argc; ++i) { values.push_back(atoi(argv[i])); }
   std::vector<std::pair<int,int> > h;
   histogram(values.begin(), values.end(), std::back_inserter(h));
   for (int i = 0; i < h.size(); ++i) {
      fprintf(stdout, "[%d,%d]\n", h[i].first, h[i].second);
   }
   return 0;
}