[c++] [container adaptor] queue

queue - FIFO

queue

template <class T, class Container = deque<T> > class queue;

표준 deque container가 아닌 다른 container 로 사용될 수 있습니다.
해당 container 는 아래 동작을 지원해야합니다.

• empty
• size
• front
• back
• push_back
• pop_front

Member types && Member Objects

#include <deque>

template <class T, class Container = std::deque<T> >
class queue {
  public:
    typedef Container                                  container_type;
    typedef typename Container::value_type             value_type;
    typedef typename Container::size_type              size_type;

  private:
    container_type C;
};

 

Member functions

explicit queue (const container_type& ctnr = container_type());
~queue();
queue& operator=( const queue& other );

explicit queue (const container_type& ctnr = container_type()) : C(ctnr) {}
queue( const queue& other ) : C(other.C) {
  *this = other;
}
~queue() {}
queue& operator=( const queue& other ) {
  this->C = other.C;
  return (*this);
}

bool empty() const;
size_type size() const;
value_type& front();
const value_type& front() const;
value_type& back();
const value_type& back() const;
void push (const value_type& val);
void pop();

push() 와 pop() 을 FIFO 에 맞게 push_back(), pop_front() 을 사용하여 구현합니다.

그림처럼 front() 는 처음 들어온 데이터를 의미하고, back() 은 마지막으로 들어온 데이터를 의미합니다.

      bool empty() const {
        return (C.empty());
      }

      size_type size() const {
        return (C.size());
      }

      value_type& front() {
        return (C.front());
      }
      const value_type& front() const {
        return (C.front());
      }

      value_type& back() {
        return (C.back());
      }
      const value_type& back() const {
        return (C.back());
      }

      void push (const value_type& val) {
        C.push_back(val);
      }
      void pop() {
        C.pop_front();
      }

Non-member function overloads

template <class T, class Container>
bool operator== (const queue<T,Container>& lhs, const queue<T,Container>& rhs);
template <class T, class Container>
bool operator!= (const queue<T,Container>& lhs, const queue<T,Container>& rhs);
template <class T, class Container>
bool operator<  (const queue<T,Container>& lhs, const queue<T,Container>& rhs);
template <class T, class Container>
bool operator<= (const queue<T,Container>& lhs, const queue<T,Container>& rhs);
template <class T, class Container>
bool operator>  (const queue<T,Container>& lhs, const queue<T,Container>& rhs);
template <class T, class Container>
bool operator>= (const queue<T,Container>& lhs, const queue<T,Container>& rhs);

queue 클래스 내부에 friend 키워드를 사용하여 private 으로 함수들의 선언합니다.

    private:
      template <class U, class V>
      friend bool operator== (const queue<U,V>& lhs, const queue<U,V>& rhs);
      template <class U, class V>
      friend bool operator!= (const queue<U,V>& lhs, const queue<U,V>& rhs);
      template <class U, class V>
      friend bool operator<  (const queue<U,V>& lhs, const queue<U,V>& rhs);
      template <class U, class V>
      friend bool operator<= (const queue<U,V>& lhs, const queue<U,V>& rhs);
      template <class U, class V>
      friend bool operator>  (const queue<U,V>& lhs, const queue<U,V>& rhs);
      template <class U, class V>
      friend bool operator>= (const queue<U,V>& lhs, const queue<U,V>& rhs);

queue 의 템플릿 인자로 들어오는 container 의 각 operator 들을 사용하여 구현합니다.

  template <class U, class V>
  bool operator== (const queue<U,V>& lhs, const queue<U,V>& rhs) {
    return (lhs.C == rhs.C);
  }
  template <class U, class V>
  bool operator!= (const queue<U,V>& lhs, const queue<U,V>& rhs) {
    return (lhs.C != rhs.C);
  }
  template <class U, class V>
  bool operator<  (const queue<U,V>& lhs, const queue<U,V>& rhs) {
    return (lhs.C < rhs.C);
  }
  template <class U, class V>
  bool operator<= (const queue<U,V>& lhs, const queue<U,V>& rhs) {
    return (lhs.C <= rhs.C);
  }
  template <class U, class V>
  bool operator>  (const queue<U,V>& lhs, const queue<U,V>& rhs) {
    return (lhs.C > rhs.C);
  }
  template <class U, class V>
  bool operator>= (const queue<U,V>& lhs, const queue<U,V>& rhs) {
    return (lhs.C >= rhs.C);
  }

참고
c++98 을 기준으로 구현했습니다.
코드 하이라이팅이 깨지는 문제에 대해 해결방법을 아시면 답변부탁드립니다!