ft_containers/stack.hpp at master · Buom01/ft_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
106
107
108
109
110
111
112
113
/* ************************************************************************** */
/*                                                                            */
/*                                                        :::      ::::::::   */
/*   stack.hpp                                          :+:      :+:    :+:   */
/*                                                    +:+ +:+         +:+     */
/*   By: badam <badam@student.42.fr>                +#+  +:+       +#+        */
/*                                                +#+#+#+#+#+   +#+           */
/*   Created: 2021/07/02 19:49:40 by badam             #+#    #+#             */
/*   Updated: 2021/10/22 16:12:12 by badam            ###   ########.fr       */
/*                                                                            */
/* ************************************************************************** */

#ifndef STACK_HPP
# define STACK_HPP

# include "vector.hpp"


namespace ft
{

template< class T, class Container = ft::vector<T> >
class stack
{
	typedef stack< T, Container >	_self;

	public:
		typedef				Container					container_type;
		typedef typename	Container::value_type		value_type;
		typedef typename	Container::size_type		size_type;
		typedef typename	Container::reference		reference;
		typedef typename	Container::const_reference	const_reference;

	protected:
		Container	c;

	public:
		explicit	stack(const Container& cont = Container()): c(cont)
		{};

		virtual		~stack(void)
		{};

		_self	&operator=(const _self &other)
		{
			c = other.c;
		};

		reference		top(void)
		{
			return (c.back());
		};

		const_reference	top(void) const
		{
			return (c.back());
		};

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

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

		void			push(const value_type& value)
		{
			c.push_back(value);
		};

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


		friend bool	operator==(const _self &lhs, const _self &rhs)
		{
			return (lhs.c == rhs.c);
		}

		friend bool	operator!=(const _self &lhs, const _self &rhs)
		{
			return (lhs.c != rhs.c);
		}

		friend bool	operator<(const _self &lhs, const _self &rhs)
		{
			return (lhs.c < rhs.c);
		}

		friend bool	operator<=(const _self &lhs, const _self &rhs)
		{
			return (lhs.c <= rhs.c);
		}

		friend bool	operator>(const _self &lhs, const _self &rhs)
		{
			return (lhs.c > rhs.c);
		}

		friend bool	operator>=(const _self &lhs, const _self &rhs)
		{
			return (lhs.c >= rhs.c);
		}
};

}

#endif