[c++] [container adaptor] stack

stack - Last In First out

stack

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

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

• empty
• size
• back
• push_back
• pop_back

Member types && Member Objects

#include <deque>

template <class T, class Container = std::deque<T> >
class stack {
  public:
    typedef Container                                  container_type;
    typedef typename Container::value_type             value_type;
    typedef typename Container::size_type              size_type;
    // c++98 에선 필요없음
    //typedef typename Container::reference              reference;
    //typedef typename Container::const_reference        const_reference;

  private:
    container_type C;
};

 

Member functions

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

 

c++98 에선 allocator 를 사용하지 않아 더 쉽게 구현이 가능합니다.

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

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

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

그림처럼 top() 은 마지막에 들어온 데이터를 의미한다. back() 을 사용하여 구현합니다.

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

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

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

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

void pop() {
  C.pop_back();
}

 

Non-member function overloads

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

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

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

 

stack 의 template 인자로 들어온 container 의 각 operator 들을 사용하여 구현합니다.

  template <class T, class Container>
  bool operator== (const stack<T,Container>& lhs, const stack<T,Container>& rhs) {
    return (lhs.C == rhs.C);
  }
  template <class T, class Container>
  bool operator!= (const stack<T,Container>& lhs, const stack<T,Container>& rhs) {
    return (lhs.C != rhs.C);
  }
  template <class T, class Container>
  bool operator<  (const stack<T,Container>& lhs, const stack<T,Container>& rhs) {
    return (lhs.C < rhs.C);
  }
  template <class T, class Container>
  bool operator<= (const stack<T,Container>& lhs, const stack<T,Container>& rhs) {
    return (lhs.C <= rhs.C);
  }
  template <class T, class Container>
  bool operator>  (const stack<T,Container>& lhs, const stack<T,Container>& rhs) {
    return (lhs.C > rhs.C);
  }
  template <class T, class Container>
  bool operator>= (const stack<T,Container>& lhs, const stack<T,Container>& rhs) {
    return (lhs.C >= rhs.C);
  }

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