MaxList.h

#ifndef MAXLIST_H
#define MAXLIST_H

#include <iostream>
#include <list>
#include <algorithm>

using std::list;

template<class Info>

class MaxList {
 public:
    
    MaxList(int size);
    MaxList(std::list<Info> lst);  
    virtual ~MaxList();
       
    int getSize();
    void insert(Info& in);
       
    typedef typename std::list<Info>::iterator pointer; 
    typedef typename std::list<Info>::reverse_iterator pointer_reverse;

    void erase(pointer pos);

    const Info* search(const Info& in);
    bool erase(const Info& in);
    void pop();
    void popBack();
    void clear();
    bool empty();
    
/*    std::list<Info>::iterator begin();
    std::list<Info>::iterator end();
    std::list<Info>::reverse_iterator rbegin();
    std::list<Info>::reverse_iterator rend();*/
    
    pointer begin();
    pointer end();
    pointer_reverse rbegin();
    pointer_reverse rend();

  private:
    int size;
    std::list<Info> mosts;
};
template<class Info>
MaxList<Info>::MaxList(int size) {
  this->size = size;
};


template<class Info>
MaxList<Info>::MaxList(std::list<Info> lst) : mosts(lst) {
  size = lst.size();
  std::sort(mosts.rbegin(), mosts.rend());
};


template<class Info>
MaxList<Info>::~MaxList() {
  mosts.clear();
};


template<class Info>
int MaxList<Info>::getSize() {
  return mosts.size();
};

template<class Info>
void MaxList<Info>::insert(Info& in) {

  if (mosts.size() == 0) {
    mosts.push_front(in);

  } else {
         
     typedef typename std::list<Info>::iterator pointer;
         
     pointer it;
    
    int j;

    bool inserted = false;
    
    for(j = 0, it = mosts.begin() ; it != mosts.end() && j < size ; it++, j++) {
      
      if (in == *it) {
        inserted = true;
        break;
        
      } else if (in > *it) {
        mosts.insert(it, in);
        inserted = true;
        break;

      } 
    }

    if(!inserted)
      mosts.push_back(in);
    
    if (mosts.size() > this->size)
      mosts.pop_back();
  }
};

template<class Info>
void MaxList<Info>::erase(pointer pos) {
  mosts.erase(pos);
  return true;
};

template<class Info>
bool MaxList<Info>::erase( const Info& in ) {
  typedef typename std::list<Info>::iterator pointer;   
  pointer it = std::find(mosts.begin(), mosts.end(), in);
  if (it == mosts.end())
    return false;

  else {
    mosts.erase(it);
    return true;
  }
};

template<class Info>
const Info* MaxList<Info>::search( const Info& in ) {

  typedef typename std::list<Info>::iterator pointer;
  
  pointer it;

  it = std::find(mosts.begin(), mosts.end(), in);

  return ( it == mosts.end() ) ? 0 : &(*it);
};

template<class Info>
void MaxList<Info>::pop() {
  mosts.pop_front();
};

template<class Info>
void MaxList<Info>::popBack() {
  mosts.pop_back();
};

template<class Info>
void MaxList<Info>::clear() {
  mosts.clear();
};

template<class Info>
bool MaxList<Info>::empty() {
  return mosts.empty();
};

template<class Info>
typename std::list<Info>::iterator MaxList<Info>::begin() {
  return mosts.begin();
};

template<class Info>
typename std::list<Info>::iterator MaxList<Info>::end() {
  return mosts.end();
};

template<class Info>
typename std::list<Info>::reverse_iterator MaxList<Info>::rbegin() {
  return mosts.rbegin();
};

template<class Info>
typename std::list<Info>::reverse_iterator MaxList<Info>::rend() {
  return mosts.rend();
};

#endif

---