ft_container/stack.hpp at master · sma96/ft_container · 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
#ifndef STACK_HPP
#define STACK_HPP

#include <iostream>
#include <stack>
#include <deque>
#include <algorithm>
#include "vector.hpp"

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

            protected :
                container_type c;

            public :
                explicit stack(const container_type& _c = container_type()) : c(_c) {};

                stack(const stack &x)
                {
                    *this = x;
                }
                ~stack(void){}

                stack &operator=(const stack &x)
                {
                    this->c = x.c;
                    return (*this);
                }

                bool emtpy() const { return (this->c.empty()); }
                size_type   size() const { return (this->c.size()); }
                reference   top() { return (this->c.back()); };
                const_reference top() const { return (this->c.back()); }
                void    push(const value_type & val) { this->c.push_back(val); }
                void    pop() { this->c.pop_back(); }
            template <class _T, class _Container>
                friend    bool    operator==(const stack<_T, _Container>& lhs, const stack<_T, _Container>& rhs);
            template <class _T, class _Container>
                friend    bool    operator<(const stack<_T, _Container>& lhs, const stack<_T, _Container>& rhs);
            template <class _T, class _Container>
                friend    bool    operator>(const stack<_T, _Container>& lhs, const stack<_T, _Container>& rhs);
            template <class _T, class _Container>
                friend    bool    operator<=(const stack<_T, _Container>& lhs, const stack<_T, _Container>& rhs);
            template <class _T, class _Container>
                friend    bool    operator>=(const stack<_T, _Container>& lhs, const stack<_T, _Container>& rhs);
            template <class _T, class _Container>
                friend    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)
        {
            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);
        }
}

#endif