containers/stack.hpp at main · nonoaa/containers · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
#ifndef STACK_HPP
#define STACK_HPP

#include "vector.hpp"

namespace ft
{
	template <class T, class Container = ft::vector<T> >
	class stack
	{
	public:
		// Vector<T>
		typedef Container									container_type;
		// T
		typedef typename container_type::value_type			value_type;
		// size_t
		typedef typename container_type::size_type			size_type;

		// C++11
		// // T&
		// typedef typename container_type::reference			reference;
		// // const T&
		// typedef typename container_type::const_reference	const_reference;
	protected:
		Container c;

	public:
		explicit stack(const container_type& cont = container_type()) : c(cont) {}
		stack &operator=(const stack& src) { c = src.c; return *this; }
		~stack() {}

		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& value)
		{
			c.push_back(value);
		}

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

		template <typename Tp, typename C>
		friend bool operator==(const stack<Tp, C>& lhs, const stack<Tp, C>& rhs);
		template <typename Tp, typename C>
		friend bool operator<(const stack<Tp, C>& lhs, const stack<Tp, C>& rhs);
	};

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

	template <typename T, typename Container>
	bool operator< (const stack<T,Container>& lhs, const stack<T,Container>& rhs)
	{
		return lhs.c < rhs.c;
	}

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

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

	template <typename T, typename Container>
	bool operator> (const stack<T,Container>& lhs, const stack<T,Container>& rhs)
	{
		return rhs < lhs;
	}

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

#endif