diff --git a/Makefile b/Makefile index a581397..10bd639 100644 --- a/Makefile +++ b/Makefile @@ -31,6 +31,8 @@ RESET = "\e[0m" # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # NAME = containers +NAME_FT = containers_ft +NAME_STL = containers_stl CC = g++ EXT = cpp @@ -39,6 +41,11 @@ CFLAGS = -Wall -Wextra -Werror $(INCLUDES) CFLAGS += -std=c++98 CFLAGS += -g3 +CFLAGS_STL = -Wall -Wextra -Werror $(INCLUDES) +CFLAGS_STL += -D STL +CFLAGS_STL += -std=c++98 +CFLAGS_STL += -g3 + VPATH = $(D_SRCS) LIBS = @@ -52,14 +59,20 @@ INCLUDES = -I$(D_HEADERS) \ D_SRCS = ./tests #SRCS = main42.cpp -SRCS = main.cpp \ - tests_definitions.cpp \ - \ - tests_vector.cpp \ - tests_map.cpp +#SRCS = main_map_1.cpp +#SRCS = main_map_2.cpp +SRCS = main_stack_1.cpp +#SRCS = \ +# main.cpp \ +# tests_definitions.cpp \ +# \ +# tests_vector.cpp \ +# tests_map.cpp \ +# tests_stack.cpp D_HEADERS = ./headers -HEADERS = colors.h \ +HEADERS = \ + colors.h \ \ enable_if.hpp \ iterator_traits.hpp \ @@ -71,30 +84,23 @@ HEADERS = colors.h \ map.hpp \ map_node.hpp \ map_iterator.hpp \ - vector.hpp -# map.hpp -# bst.hpp -# bst_node.hpp -# bst_iterator.hpp + vector.hpp \ + stack.hpp D_TEMPLATES = ./templates -TEMPLATES = bst.tpp \ - \ - vector.tpp -# map.tpp +TEMPLATES = \ + vector.tpp \ + map.tpp D_TESTS = ./tests/includes -TESTS = main.hpp \ +TESTS = \ + main.hpp \ tests_utils.hpp -D_OBJS = builds -OBJS = $(SRCS:%.$(EXT)=$(D_OBJS)/%.o) - -ifeq "$(D_OBJS)" "." - RM_OBJS = rm -f $(OBJS) -else - RM_OBJS = rm -rf $(D_OBJS) -endif +D_OBJS_FT = builds_ft +OBJS_FT = $(SRCS:%.$(EXT)=$(D_OBJS_FT)/%.o) +D_OBJS_STL = builds_stl +OBJS_STL = $(SRCS:%.$(EXT)=$(D_OBJS_STL)/%.o) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # @@ -103,37 +109,42 @@ endif # . @recipe (silent) . $^ : all prerequisites # # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # -all: $(NAME) +all: $(NAME_FT) $(NAME_STL) -stl: CFLAGS += -D STL -stl: re -ft: re +stl: $(NAME_STL) +ft: $(NAME_FT) -leakstl: CFLAGS += -D STL -leakstl: fclean leaks -leakft: fclean leaks - -$(D_OBJS)/%.o: %.$(EXT) | $(D_OBJS) +$(D_OBJS_FT)/%.o: %.$(EXT) | $(D_OBJS_FT) @echo $(CYAN)"compilation " $@ $(RESET) @$(CC) $(CFLAGS) -c $< -o $@ +$(D_OBJS_STL)/%.o: %.$(EXT) | $(D_OBJS_STL) + @echo $(CYAN)"compilation -D STL" $@ $(RESET) + @$(CC) $(CFLAGS) -D STL -c $< -o $@ -$(D_OBJS): +$(D_OBJS_FT) $(D_OBJS_STL): mkdir $@ $(OBJS): $(F_INCLUDES) -$(NAME): $(OBJS) - @echo $(CYAN)"linkage (link objects.o) :"$(RESET) - $(CC) $(OBJS) -o $@ $(LIBS) +# https://stackoverflow.com/questions/19259108/makefile-same-rule-for-multiple-targets +$(NAME_FT): $(OBJS_FT) +$(NAME_STL): $(OBJS_STL) +$(NAME_FT) $(NAME_STL): + @echo $(CYAN)"linkage (link objects.o)"$(RESET) + @$(CC) $^ -o $@ $(LIBS) -leaks: $(NAME) - valgrind --leak-check=full --show-leak-kinds=all ./$(NAME) +leaks: leaksft +leaksft: $(NAME_FT) + valgrind --leak-check=full --show-leak-kinds=all ./$< +leakstl: $(NAME_STL) + valgrind --leak-check=full --show-leak-kinds=all ./$< clean: - $(RM_OBJS) + rm -rf $(D_OBJS_FT) + rm -rf $(D_OBJS_STL) fclean: clean - rm -f $(NAME) + rm -f $(NAME_FT) $(NAME_STL) re: fclean all diff --git a/containers_ft b/containers_ft new file mode 100755 index 0000000..752db1a Binary files /dev/null and b/containers_ft differ diff --git a/headers/bak__bst.hpp b/headers/bak__bst.hpp index f7dab8c..a79e8cb 100644 --- a/headers/bak__bst.hpp +++ b/headers/bak__bst.hpp @@ -21,96 +21,135 @@ template < typename T, typename Compare = std::less, typename Allocator = std::allocator< ft::pair > -> class Bst -{ - public: - typedef Key key_type; - typedef T mapped_type; - typedef pair value_type; - typedef Compare key_compare; - typedef Allocator allocator_type; - typedef std::size_t size_type; - typedef std::ptrdiff_t difference_type; +> class Bst { - typedef typename Allocator::pointer pointer; - typedef typename Allocator::const_pointer const_pointer; - typedef typename Allocator::reference reference; - typedef typename Allocator::const_reference const_reference; +public: + typedef Key key_type; + typedef T mapped_type; + typedef pair value_type; + typedef Compare key_compare; + typedef Allocator allocator_type; + typedef std::size_t size_type; + typedef std::ptrdiff_t difference_type; + + typedef Bst_iterator iterator; + typedef Bst_const_iterator const_iterator; + typedef ft::reverse_iterator reverse_iterator; + typedef ft::reverse_iterator const_reverse_iterator; - typedef Bst_iterator iterator; - typedef Bst_const_iterator const_iterator; - typedef ft::reverse_iterator reverse_iterator; - typedef ft::reverse_iterator const_reverse_iterator; + /************ + * copliens : + ************/ +// constructors ------------------------------ + explicit Bst( + const key_compare& comp = Compare(), + const Allocator& alloc = Allocator() + ); + template < typename InputIt > + Bst( + InputIt first, InputIt last, + const key_compare& comp = Compare(), + const allocator_type& alloc = Allocator() + ); + Bst(const Bst& src); +// destructor -------------------------------- + ~Bst(); +// operator= --------------------------------- + Bst& operator=(const Bst& rhs); - // Member functions - explicit Bst(const Compare& comp = Compare(), const Allocator& alloc = Allocator() ); - template < typename InputIt > - Bst(InputIt first, InputIt last, const Compare& comp = Compare(), const Allocator& alloc = Allocator()); - Bst(const Bst& src); - ~Bst(); + /************* + * iterators : + *************/ +// begin ------------------------------------- + iterator begin(); + const_iterator begin() const; +// end --------------------------------------- + iterator end(); + const_iterator end() const; +// rbegin ------------------------------------ + reverse_iterator rbegin(); + const_reverse_iterator rbegin() const; +// rend -------------------------------------- + reverse_iterator rend(); + const_reverse_iterator rend() const; - Bst& operator=(const Bst& rhs); - // Element access - T& operator[](const Key& key); + /************ + * capacity : + ************/ +// empty ------------------------------------- + bool empty() const; +// size -------------------------------------- + size_type size() const; +// max_size ---------------------------------- + size_type max_size() const; - // Iterators - iterator begin(); - const_iterator begin() const; - iterator end(); - const_iterator end() const; - reverse_iterator rbegin(); - const_reverse_iterator rbegin() const; - reverse_iterator rend(); - const_reverse_iterator rend() const; - // Capacity - bool empty() const; - size_type size() const; - size_type max_size() const; + /****************** + * element access : + ******************/ +// operator[] -------------------------------- + mapped_type& operator[](const key_type& key); - // Modifiers - void clear(); - pair insert(const value_type& value); - iterator insert(iterator hint, const value_type& value); - template < typename InputIt > - void insert(InputIt first, InputIt last); - void erase(iterator pos); - void erase(iterator first, iterator last); - size_type erase(const Key& key); - void swap(Bst& other); - // Lookup - iterator find(const Key& key); - const_iterator find(const Key& key) const; - size_type count(const Key& key) const; + /************* + * modifiers : + *************/ +// insert ------------------------------------ + pair insert(const value_type& value); + iterator insert(iterator hint, const value_type& value); + template < typename InputIt > + void insert(InputIt first, InputIt last); +// erase ------------------------------------- + void erase(iterator pos); + size_type erase(const key_type& key); + void erase(iterator first, iterator last); +// swap -------------------------------------- + void swap(Bst& other); +// clear ------------------------------------- + void clear(); - private: - size_type _size; - node* _root; - node_sentinel* _sentinel; - Compare _comp; - Allocator _allocator; + /************** + * operations : + **************/ +// find -------------------------------------- + iterator find(const key_type& key); + const_iterator find(const key_type& key) const; +// count ------------------------------------- + size_type count(const key_type& key) const; - // TODO : rebind syntaxe pas clair. - typename Allocator::template rebind< node >::other _allocator_node; // Peu clair, verifier syntaxe - typename Allocator::template rebind< node_sentinel >::other _allocator_node_sentinel; // Peu clair, verifier syntaxe +private: + size_type _size; + node* _root; + node_sentinel* _sentinel; + Compare _comp; + Allocator _allocator; - void _init_sentinel(); - pair _insert(const value_type& value); - node* _erase(iterator pos); - node* _subtree_shift(node* st_old, node* st_new); + // https://stackoverflow.com/questions/14148756/what-does-template-rebind-do + typename Allocator::template + rebind< node >::other _allocator_node; + typename Allocator::template + rebind< node_sentinel >::other _allocator_node_sentinel; - // AVL Balancing - void _insert_rebalancing(node* n); - void _erase_rebalancing(node* n); + void _init_sentinel(); + pair _insert(const value_type& value); + node* _erase(iterator pos); + node* _subtree_shift( + node* st_old, + node* st_new + ); - short _compute_height(node* n); - short _bf(node* n); // balance factor - node* _rotate_left(node* n); - node* _rotate_right(node* n); + // BBST + // https://www.youtube.com/watch?v=vRwi_UcZGjU + void _insert_rebalancing(node* n); + void _erase_rebalancing(node* n); + + short _compute_height(node* n); + short _balance_factor(node* n); + node* _rotate_left(node* n); + node* _rotate_right(node* n); }; // Non-member functions diff --git a/headers/bak__map.hpp b/headers/bak__map.hpp index 76bea02..137c4fd 100644 --- a/headers/bak__map.hpp +++ b/headers/bak__map.hpp @@ -2,7 +2,6 @@ #ifndef MAP_HPP # define MAP_HPP -# include "colors.h" # include // std::allocator # include // NULL, std::size_t, std::ptrdiff_t # include // std::less, std::binary_function @@ -29,11 +28,6 @@ public: typedef Compare key_compare; typedef Alloc allocator_type; -// typedef typename allocator_type::reference reference; -// typedef typename allocator_type::const_reference const_reference; -// typedef typename allocator_type::pointer pointer; -// typedef typename allocator_type::const_pointer const_pointer; - typedef Bst bst_map; typedef typename bst_map::iterator iterator; @@ -203,5 +197,11 @@ template< class Key, class T, class Compare, class Alloc > void swap # include "map.tpp" +// banlanced binary search tree : +// https://www.youtube.com/watch?v=vRwi_UcZGjU + +// entinel node : +// https://en.wikipedia.org/wiki/Sentinel_node + #endif diff --git a/headers/map.hpp b/headers/map.hpp index 9ab5e19..2ce22a6 100644 --- a/headers/map.hpp +++ b/headers/map.hpp @@ -4,7 +4,7 @@ # include // std::allocator # include // NULL, std::size_t, std::ptrdiff_t -# include // max() +# include // std::max() # include // std::less, std::binary_function # include "reverse_iterator.hpp" @@ -22,27 +22,29 @@ template < class T, // map::mapped_type class Compare = std::less, // map::key_compare class Alloc = std::allocator< ft::pair > // map::allocator_type -> class map -{ - public: - typedef Key key_type; - typedef T mapped_type; - typedef pair value_type; - typedef Compare key_compare; - typedef Alloc allocator_type; - typedef std::size_t size_type; - typedef std::ptrdiff_t difference_type; +> class map { - // typedef typename Alloc::pointer pointer; - // typedef typename Alloc::const_pointer const_pointer; - // typedef typename Alloc::reference reference; - // typedef typename Alloc::const_reference const_reference; +public: - typedef map_iterator iterator; - typedef map_const_iterator const_iterator; - typedef ft::reverse_iterator reverse_iterator; - typedef ft::reverse_iterator const_reverse_iterator; + typedef Key key_type; + typedef T mapped_type; + typedef pair value_type; + typedef std::size_t size_type; + typedef std::ptrdiff_t difference_type; + typedef Compare key_compare; + typedef Alloc allocator_type; + typedef map_iterator iterator; + typedef map_const_iterator const_iterator; + typedef ft::reverse_iterator reverse_iterator; + typedef ft::reverse_iterator const_reverse_iterator; + + + /**************** + * member class : + ****************/ + // https://en.cppreference.com/w/cpp/container/map/value_compare + // https://stackoverflow.com/questions/4571355/why-would-one-use-nested-classes-in-c class value_compare : public std::binary_function { friend class map; @@ -54,105 +56,172 @@ template < { return comp(x.first, y.first); } }; - // Member functions - explicit map(const Compare& comp = Compare(), const Alloc& alloc = Alloc() ); - template < typename InputIt > - map(InputIt first, InputIt last, const Compare& comp = Compare(), const Alloc& alloc = Alloc()); - map(const map& src); - ~map(); - map& operator=(const map& rhs); + /************ + * copliens : + ************/ +// constructors ------------------------------ + explicit map (const key_compare& comp = key_compare(), + const allocator_type& alloc = allocator_type()); + template + map (InputIterator first, InputIterator last, + const key_compare& comp = key_compare(), + const allocator_type& alloc = allocator_type()); + map(const map& x); +// destructor -------------------------------- + ~map(); +// operator= --------------------------------- + map& operator= (const map& x); - // Element access - T& operator[](const Key& key); - // Iterators - iterator begin(); - const_iterator begin() const; - iterator end(); - const_iterator end() const; - reverse_iterator rbegin(); - const_reverse_iterator rbegin() const; - reverse_iterator rend(); - const_reverse_iterator rend() const; + /************* + * iterators : + *************/ +// begin ------------------------------------- + iterator begin(); + const_iterator begin() const; +// end --------------------------------------- + iterator end(); + const_iterator end() const; +// rbegin ------------------------------------ + reverse_iterator rbegin(); + const_reverse_iterator rbegin() const; +// rend -------------------------------------- + reverse_iterator rend(); + const_reverse_iterator rend() const; - // Capacity - bool empty() const; - size_type size() const; - size_type max_size() const; - // Modifiers - void clear(); - pair insert(const value_type& value); - iterator insert(iterator hint, const value_type& value); - template < typename InputIt > - void insert(InputIt first, InputIt last); - void erase(iterator pos); - void erase(iterator first, iterator last); - size_type erase(const Key& key); - void swap(map& other); + /************ + * capacity : + ************/ +// empty ------------------------------------- + bool empty() const; +// size -------------------------------------- + size_type size() const; +// max_size ---------------------------------- + size_type max_size() const; - // Lookup - iterator find(const Key& key); - const_iterator find(const Key& key) const; - size_type count(const Key& key) const; - private: - size_type _size; - node* _root; - node_sentinel* _sentinel; - Compare _comp; - Alloc _allocator; + /****************** + * element access : + ******************/ +// operator[] -------------------------------- + mapped_type & operator[] (const key_type& k); - // TODO : rebind syntaxe pas clair. - typename Alloc::template rebind< node >::other _allocator_node; // Peu clair, verifier syntaxe - typename Alloc::template rebind< node_sentinel >::other _allocator_node_sentinel; // Peu clair, verifier syntaxe - void _init_sentinel(); - pair _insert(const value_type& value); - node* _erase(iterator pos); - node* _subtree_shift(node* st_old, node* st_new); + /************* + * modifiers : + *************/ +// insert ------------------------------------ + pair insert (const value_type& val); + iterator insert (iterator position, const value_type& val); + template + void insert (InputIterator first, InputIterator last); +// erase ------------------------------------- + void erase (iterator position); + size_type erase (const key_type& k); + void erase (iterator first, iterator last); +// swap -------------------------------------- + void swap (map& x); +// clear ------------------------------------- + void clear(); - // AVL Balancing - void _insert_rebalancing(node* n); - void _erase_rebalancing(node* n); - short _compute_height(node* n); - short _bf(node* n); // balance factor - node* _rotate_left(node* n); - node* _rotate_right(node* n); + /************* + * observers : + *************/ +// key_comp ---------------------------------- + key_compare key_comp() const; +// value_comp -------------------------------- + value_compare value_comp() const; + + + /************** + * operations : + **************/ +// find -------------------------------------- + iterator find (const key_type& k); + const_iterator find (const key_type& k) const; +// count ------------------------------------- + size_type count (const key_type& k) const; +// lower_bound ------------------------------- + iterator lower_bound (const key_type& k); + const_iterator lower_bound (const key_type& k) const; +// upper_bound ------------------------------- + iterator upper_bound (const key_type& k); + const_iterator upper_bound (const key_type& k) const; +// equal_range ------------------------------- + pair equal_range (const key_type& k) const; + pair equal_range (const key_type& k); + + + /************* + * allocator : + *************/ +// get_allocator ----------------------------- + allocator_type get_allocator() const; + +private: + size_type _size; + node* _root; + node_sentinel* _sentinel; + Compare _comp; + Alloc _allocator; + + // https://stackoverflow.com/questions/14148756/what-does-template-rebind-do + typename Alloc::template rebind< node >::other _allocator_node; // Peu clair, verifier syntaxe + typename Alloc::template rebind< node_sentinel >::other _allocator_node_sentinel; // Peu clair, verifier syntaxe // SENTINELL + + void _init_sentinel(); + pair _insert(const value_type& value); + node* _erase(iterator pos); + node* _subtree_shift(node* st_old, node* st_new); + + // BBST + void _insert_rebalancing(node* n); + void _erase_rebalancing(node* n); + + short _compute_height(node* n); + short _balance_factor(node* n); + node* _rotate_left(node* n); + node* _rotate_right(node* n); }; - // Non-member functions - template < typename Key, typename T, typename Compare, typename Alloc > - bool operator==(const map& lhs, const map& rhs); - template < typename Key, typename T, typename Compare, typename Alloc > - bool operator!=(const map& lhs, const map& rhs); - template < typename Key, typename T, typename Compare, typename Alloc > - bool operator<(const map& lhs, const map& rhs); - template < typename Key, typename T, typename Compare, typename Alloc > - bool operator>(const map& lhs, const map& rhs); - template < typename Key, typename T, typename Compare, typename Alloc > - bool operator<=(const map& lhs, const map& rhs); - template < typename Key, typename T, typename Compare, typename Alloc > - bool operator>=(const map& lhs, const map& rhs); - template < typename Key, typename T, typename Compare, typename Alloc > - void swap(map& lhs, map& rhs); + /************************ + * non-member functions : + ************************/ +// operator == ------------------------------- +template< class K, class T, class Comp, class Alloc > bool operator== + ( const std::map& lhs, const std::map& rhs ); +// operator != ------------------------------- +template< class K, class T, class Comp, class Alloc > bool operator!= + ( const std::map& lhs, const std::map& rhs ); +// operator < -------------------------------- +template< class K, class T, class Comp, class Alloc > bool operator< + ( const std::map& lhs, const std::map& rhs ); +// operator <= ------------------------------- +template< class K, class T, class Comp, class Alloc > bool operator<= + ( const std::map& lhs, const std::map& rhs ); +// operator > -------------------------------- +template< class K, class T, class Comp, class Alloc > bool operator> + ( const std::map& lhs, const std::map& rhs ); +// operator >= ------------------------------- +template< class K, class T, class Comp, class Alloc > bool operator>= + ( const std::map& lhs, const std::map& rhs ); +// swap (map) ----------------------------- +template< class Key, class T, class Compare, class Alloc > void swap + ( std::map& lhs, std::map& rhs ); } // namespace ft -# include "bst.tpp" +# include "map.tpp" -// https://en.wikipedia.org/wiki/Binary_search_tree -// https://en.wikipedia.org/wiki/AVL_tree - -// https://fr.wikipedia.org/wiki/Arbre_binaire_de_recherche -// https://fr.wikipedia.org/wiki/Arbre_AVL - -// https://visualgo.net/en/bst -// https://visualgo.net/en/bst?slide=14-8 // --> to 14-13 +// banlanced binary search tree : +// https://www.youtube.com/watch?v=vRwi_UcZGjU +// entinel node : +// https://en.wikipedia.org/wiki/Sentinel_node #endif diff --git a/headers/map_iterator.hpp b/headers/map_iterator.hpp index 9a70567..c588098 100644 --- a/headers/map_iterator.hpp +++ b/headers/map_iterator.hpp @@ -27,8 +27,8 @@ template < typedef value_type& reference; map_iterator() : _node(), _sentinel() {} - map_iterator(node* n, node_sentinel* sentinel) : _node(n), _sentinel(sentinel) {} - //map_iterator(const map_iterator& src) : _node(src._node), _sentinel(src._sentinel) {} //implicit + map_iterator(node* n, node_sentinel* sentinel) : _node(n), _sentinel(sentinel) {} // SENTINELL + //map_iterator(node* n, node* sentinel) : _node(n), _sentinel(sentinel) {} reference operator*() const { return _node->value; } @@ -38,7 +38,8 @@ template < Self& operator++() { if (_node == NULL) - _node = _sentinel->child->min(); + _node = _sentinel->child->min(); // SENTINELL + //_node = _sentinel->min(); else if (_node->right) _node = _node->right->min(); else @@ -57,7 +58,8 @@ template < Self& operator--() { if (_node == NULL) - _node = _sentinel->child->max(); + _node = _sentinel->child->max(); // SENTINELL + //_node = _sentinel->max(); else if (_node->left) _node = _node->left->max(); else @@ -93,7 +95,8 @@ template < { return _node; } const node* getNode() const { return _node; } - const node_sentinel* getSentinel() const + const node_sentinel* getSentinel() const // SENTINELL + //const node* getSentinel() const { return _sentinel; } // TODO : friend Non-member functions syntaxe pas clair. @@ -104,7 +107,8 @@ template < private: node* _node; - node_sentinel* _sentinel; + node_sentinel* _sentinel; // SENTINELL + //node* _sentinel; }; template < @@ -125,8 +129,8 @@ template < typedef const value_type& reference; map_const_iterator() : _node(), _sentinel() {} - map_const_iterator(const node* node, const node_sentinel* sentinel) : _node(node), _sentinel(sentinel) {} - //map_const_iterator(const map_const_iterator& src) : _node(src._node), _sentinel(src._sentinel) {} //implicit + map_const_iterator(const node* node, const node_sentinel* sentinel) : _node(node), _sentinel(sentinel) {} // SENTINELL + //map_const_iterator(const node* nodee, const node* sentinel) : _node(nodee), _sentinel(sentinel) {} map_const_iterator(const map_iterator& src) : _node(src.getNode()), _sentinel(src.getSentinel()) {} reference operator*() const @@ -137,7 +141,8 @@ template < Self& operator++() { if (_node == NULL) - _node = _sentinel->child->min(); + _node = _sentinel->child->min(); // SENTINELL + //_node = _sentinel->min(); else if (_node->right) _node = _node->right->min(); else @@ -156,7 +161,8 @@ template < Self& operator--() { if (_node == NULL) - _node = _sentinel->child->max(); + _node = _sentinel->child->max(); // SENTINELL + //_node = _sentinel->max(); else if (_node->left) _node = _node->left->max(); else @@ -174,7 +180,6 @@ template < Self operator++(int) { - //Self old(*this); Self old = *this; ++(*this); return old; @@ -182,7 +187,6 @@ template < Self operator--(int) { - //Self old(*this); Self old = *this; --(*this); return old; @@ -198,7 +202,8 @@ template < private: const node* _node; - const node_sentinel* _sentinel; + const node_sentinel* _sentinel; // SENTINELL + //const node* _sentinel; }; } // namespace ft diff --git a/headers/map_node.hpp b/headers/map_node.hpp index 3481ca9..0982288 100644 --- a/headers/map_node.hpp +++ b/headers/map_node.hpp @@ -7,18 +7,24 @@ namespace ft { template < typename ValueType > -struct node -{ + struct node { + ValueType value; node *up; node *left; node *right; short height; - node(const ValueType& val) : value(val), up(NULL), left(NULL), right(NULL), height(1) {} + node(const ValueType& val) + : value(val) + , up(NULL) + , left(NULL) + , right(NULL) + , height(1) + {} + + node* min() { - node* min() - { node* n = this; while (n->left) @@ -26,8 +32,8 @@ struct node return n; } - node* max() - { + node* max() { + node* n = this; while (n->right) @@ -37,8 +43,8 @@ struct node }; template < typename ValueType > -struct node_sentinel -{ + struct node_sentinel { + node *child; node_sentinel() : child(NULL) {} diff --git a/headers/stack.hpp b/headers/stack.hpp new file mode 100644 index 0000000..6ef6393 --- /dev/null +++ b/headers/stack.hpp @@ -0,0 +1,94 @@ + +#ifndef STACK_HPP +# define STACK_HPP + +# include "vector.hpp" + +namespace ft { + +template < + typename T, + typename Container = ft::vector +> class stack +{ +public: + typedef Container container_type; + typedef typename Container::value_type value_type; + typedef typename Container::size_type size_type; + + + /************ + * copliens : + ************/ +// constructors ------------------------------ + explicit stack(const container_type& cont = Container()) : c(cont) {} + explicit stack(stack const &other): c(other.c) {} + + + /********************** + * overload functions : + **********************/ +// empty ------------------------------------- + bool empty() const { return c.empty(); } +// size -------------------------------------- + size_type size() const { return c.size(); } +// top --------------------------------------- + value_type& top() { return c.back(); } + const value_type& top() const { return c.back(); } +// push -------------------------------------- + void push(const value_type& value) { c.push_back(value); } +// pop --------------------------------------- + void pop() { c.pop_back(); } + +// Relational Operators (friend) + template < typename T2, typename C2 > + friend bool operator==(const stack& lhs, const stack& rhs); + template < typename T2, typename C2 > + friend bool operator!=(const stack& lhs, const stack& rhs); + template < typename T2, typename C2 > + friend bool operator<(const stack& lhs, const stack& rhs); + template < typename T2, typename C2 > + friend bool operator>(const stack& lhs, const stack& rhs); + template < typename T2, typename C2 > + friend bool operator<=(const stack& lhs, const stack& rhs); + template < typename T2, typename C2 > + friend bool operator>=(const stack& lhs, const stack& rhs); + +protected: + Container c; + +}; + + + /************************ + * non-member functions : + ************************/ +// operator == ------------------------------- +template < typename T, typename Container > + bool operator==(const stack& lhs, const stack& rhs) + { return lhs.c == rhs.c; } +// operator != ------------------------------- +template < typename T, typename Container > + bool operator!=(const stack& lhs, const stack& rhs) + { return lhs.c != rhs.c; } +// operator < -------------------------------- +template < typename T, typename Container > + bool operator<(const stack& lhs, const stack& rhs) + { return lhs.c < rhs.c; } +// operator > -------------------------------- +template < typename T, typename Container > + bool operator>(const stack& lhs, const stack& rhs) + { return lhs.c > rhs.c; } +// operator <= ------------------------------- +template < typename T, typename Container > + bool operator<=(const stack& lhs, const stack& rhs) + { return lhs.c <= rhs.c; } +// operator >= ------------------------------- +template < typename T, typename Container > + bool operator>=(const stack& lhs, const stack& rhs) + { return lhs.c >= rhs.c; } + +} // namespace ft + +#endif + diff --git a/templates/bst_bak.tpp b/templates/bak__bst.tpp similarity index 84% rename from templates/bst_bak.tpp rename to templates/bak__bst.tpp index 0ade6c0..d9402be 100644 --- a/templates/bst_bak.tpp +++ b/templates/bak__bst.tpp @@ -8,55 +8,49 @@ namespace ft { ////////////////////// // Member functions // -BST_TEMPLATE -BST:: - Bst(const Compare& comp, const Allocator& alloc) : -_size(0), -_root(NULL), -_comp(comp), -_allocator(alloc) -{ +BST_TEMPLATE BST:: + Bst(const Compare& comp, const Allocator& alloc) + : _size(0) + , _root(NULL) + , _comp(comp) + , _allocator(alloc) { + _init_sentinel(); } -BST_TEMPLATE -template < typename InputIt > -BST:: - Bst(InputIt first, InputIt last, const Compare& comp, const Allocator& alloc) : -_size(0), -_root(NULL), -_comp(comp), -_allocator(alloc) -{ +BST_TEMPLATE template < typename InputIt > BST:: + Bst(InputIt first, InputIt last, const Compare& comp, const Allocator& alloc) + : _size(0) + , _root(NULL) + , _comp(comp) + , _allocator(alloc) { + _init_sentinel(); insert(first, last); } -BST_TEMPLATE -BST:: - Bst(const Bst& src) : -_size(0), -_root(NULL), -_comp(src._comp), -_allocator(src._allocator) -{ +BST_TEMPLATE BST:: + Bst(const Bst& src) + : _size(0) + , _root(NULL) + , _comp(src._comp) + , _allocator(src._allocator) { + _init_sentinel(); *this = src; } -BST_TEMPLATE -BST:: - ~Bst() -{ +BST_TEMPLATE BST:: + ~Bst() { + clear(); _allocator_node_sentinel.destroy(_sentinel); _allocator_node_sentinel.deallocate(_sentinel, 1); } -BST_TEMPLATE -BST& BST:: - operator=(const Bst& rhs) -{ +BST_TEMPLATE BST& BST:: + operator=(const Bst& rhs) { + if (this == &rhs) return (*this); Bst new_bst(rhs.begin(), rhs.end()); @@ -68,10 +62,9 @@ BST& BST:: //////////////////// // Element access // -BST_TEMPLATE -T& BST:: - operator[](const Key& key) -{ +BST_TEMPLATE T& BST:: + operator[](const Key& key) { + node* n = _root; //node* prev = NULL; @@ -96,64 +89,53 @@ T& BST:: /////////////// // Iterators // -BST_TEMPLATE -typename BST::iterator BST:: - begin() -{ +BST_TEMPLATE typename BST::iterator BST:: + begin() { + if (_root) return iterator(_root->min(), _sentinel); else return end(); } -BST_TEMPLATE -typename BST::const_iterator BST:: - begin() const -{ +BST_TEMPLATE typename BST::const_iterator BST:: + begin() const { + if (_root) return const_iterator(_root->min(), _sentinel); else return end(); } -BST_TEMPLATE -typename BST::iterator BST:: +BST_TEMPLATE typename BST::iterator BST:: end() { return iterator(NULL, _sentinel); } -BST_TEMPLATE -typename BST::const_iterator BST:: +BST_TEMPLATE typename BST::const_iterator BST:: end() const { return const_iterator(NULL, _sentinel); } -BST_TEMPLATE -typename BST::reverse_iterator BST:: +BST_TEMPLATE typename BST::reverse_iterator BST:: rbegin() { return reverse_iterator(end()); } -BST_TEMPLATE -typename BST::const_reverse_iterator BST:: +BST_TEMPLATE typename BST::const_reverse_iterator BST:: rbegin() const { return const_reverse_iterator(end()); } -BST_TEMPLATE -typename BST::reverse_iterator BST:: +BST_TEMPLATE typename BST::reverse_iterator BST:: rend() { return reverse_iterator(begin()); } -BST_TEMPLATE -typename BST::const_reverse_iterator BST:: +BST_TEMPLATE typename BST::const_reverse_iterator BST:: rend() const { return const_reverse_iterator(begin()); } ////////////// // Capacity // -BST_TEMPLATE -bool BST:: +BST_TEMPLATE bool BST:: empty() const { return (_size == 0); } -BST_TEMPLATE -typename BST::size_type BST:: +BST_TEMPLATE typename BST::size_type BST:: size() const { return (_size); } -BST_TEMPLATE -typename BST::size_type BST:: +BST_TEMPLATE typename BST::size_type BST:: max_size() const { return ( _allocator_node.max_size() ); @@ -419,19 +401,19 @@ void BST:: { n->height = _compute_height(n); - if (_bf(n) > 1) // Left Heavy + if (_balance_factor(n) > 1) // Left Heavy { parent = n->up; - if (_bf(n->left) < 0) // Left-Right Case (BF == -1) + if (_balance_factor(n->left) < 0) // Left-Right Case (BF == -1) n->left = _rotate_left(n->left); // Left-Left Case n = _rotate_right(n); old_n = n->right; } - else if (_bf(n) < -1) // Right Heavy + else if (_balance_factor(n) < -1) // Right Heavy { parent = n->up; - if (_bf(n->right) > 0) // Right-Left Case (BF == 1) + if (_balance_factor(n->right) > 0) // Right-Left Case (BF == 1) n->right = _rotate_right(n->right); // Right-Right Case n = _rotate_left(n); @@ -468,19 +450,19 @@ void BST:: { n->height = _compute_height(n); - if (_bf(n) > 1) // Left Heavy + if (_balance_factor(n) > 1) // Left Heavy { parent = n->up; - if (_bf(n->left) < 0) // Left-Right Case (BF == -1) + if (_balance_factor(n->left) < 0) // Left-Right Case (BF == -1) n->left = _rotate_left(n->left); // Left-Left Case n = _rotate_right(n); old_n = n->right; } - else if (_bf(n) < -1) // Right Heavy + else if (_balance_factor(n) < -1) // Right Heavy { parent = n->up; - if (_bf(n->right) > 0) // Right-Left Case (BF == 1) + if (_balance_factor(n->right) > 0) // Right-Left Case (BF == 1) n->right = _rotate_right(n->right); // Right-Right Case n = _rotate_left(n); @@ -514,10 +496,9 @@ short BST:: return 1; } -BST_TEMPLATE -short BST:: - _bf(node* n) // optimisation possible if assume n have at least one child ? -{ +BST_TEMPLATE short BST:: + _balance_factor(node* n) { + if (n->left && n->right) return n->left->height - n->right->height; else if (n->left) @@ -528,10 +509,9 @@ short BST:: return 0; } -BST_TEMPLATE -node* BST:: - _rotate_left(node* n) // assume n->right != NULL -{ +BST_TEMPLATE node* BST:: + _rotate_left(node* n) { + node* ori_right = n->right; ori_right->up = n->up; @@ -554,10 +534,9 @@ node* BST:: return ori_right; // return new sub-tree root } -BST_TEMPLATE -node* BST:: - _rotate_right(node* n) // assume n->left != NULL -{ +BST_TEMPLATE node* BST:: + _rotate_right(node* n) { + node* ori_left = n->left; ori_left->up = n->up; diff --git a/templates/bak__map.tpp b/templates/bak__map.tpp new file mode 100644 index 0000000..250c37d --- /dev/null +++ b/templates/bak__map.tpp @@ -0,0 +1,268 @@ + +#define MP_TPL template < typename Key, typename T, typename Compare, typename Alloc > +#define MP map + +namespace ft { + + + /************ + * copliens : + ************/ +// constructors ------------------------------ +MP_TPL MP:: + map (const key_compare & comp, const allocator_type & alloc) + : _bst() + , _allocator(alloc) + , _comp(comp) { + + return; +} +MP_TPL template MP:: + map (InputIt first, InputIt last, const key_compare& comp, const allocator_type& alloc) + : _bst(first, last) + , _allocator(alloc) + , _comp(comp) { +} +MP_TPL MP:: + map (const map& x) + : _bst() + , _allocator(x._allocator) + , _comp(x._comp) { + + *this = x; +} +// destructor -------------------------------- +MP_TPL MP:: + ~map() { clear(); } +// operator= --------------------------------- +MP_TPL MP& MP:: + operator= (const map& x) { + + if (this == &x) + return (*this); + + map new_map(x.begin(), x.end()); + swap(new_map); + return (*this); +} + + + /************* + * iterators : + *************/ +// begin ------------------------------------- +MP_TPL typename MP::iterator MP:: + begin() { return (_bst.begin()); } +MP_TPL typename MP::const_iterator MP:: + begin() const { return (_bst.begin()); } +// end --------------------------------------- +MP_TPL typename MP::iterator MP:: + end() { return (_bst.end()); } +MP_TPL typename MP::const_iterator MP:: + end() const { return (_bst.end()); } +// rbegin ------------------------------------ +MP_TPL typename MP::reverse_iterator MP:: + rbegin() { return (_bst.rbegin()); } +MP_TPL typename MP::const_reverse_iterator MP:: + rbegin() const { return (_bst.rbegin()); } +// rend -------------------------------------- +MP_TPL typename MP::reverse_iterator MP:: + rend() { return (_bst.rend()); } +MP_TPL typename MP::const_reverse_iterator MP:: + rend() const { return (_bst.rend()); } + + + /************ + * capacity : + ************/ +// empty ------------------------------------- +MP_TPL bool MP:: + empty() const { return (_bst.empty()); } +// size -------------------------------------- +MP_TPL typename MP::size_type MP:: + size() const { return (_bst.size()); } +// max_size ---------------------------------- +MP_TPL typename MP::size_type MP:: + max_size() const { return (_bst.max_size()); } + + + /****************** + * element access : + ******************/ +// operator[] -------------------------------- +MP_TPL typename MP::mapped_type& MP:: + operator[] (const key_type& k) { return _bst[k]; } + + + /************* + * modifiers : + *************/ +// insert ------------------------------------ +MP_TPL pair MP:: + insert (const value_type& val) { return (_bst.insert(val)); } +MP_TPL typename MP::iterator MP:: + insert (iterator pos, const value_type& val) { return (_bst.insert(pos, val)); } +MP_TPL template void MP:: + insert (InputIt first, InputIt last) { return (_bst.insert(first, last)); } +// erase ------------------------------------- +MP_TPL void MP:: + erase (iterator pos) { return (_bst.erase(pos)); } +MP_TPL typename MP::size_type MP:: + erase (const key_type& k) { return (_bst.erase(k)); } +MP_TPL void MP:: + erase (iterator first, iterator last) { return (_bst.erase(first, last)); } +// swap -------------------------------------- +MP_TPL void MP:: + swap (map& x) { + + bst_map tmp; + + tmp.swap(_bst); + _bst.swap(x._bst); + x._bst.swap(tmp); +} +// clear ------------------------------------- +MP_TPL void MP:: + clear() { + + _bst.clear(); +} + + + /************* + * observers : + *************/ +// key_comp ---------------------------------- +MP_TPL typename MP::key_compare MP:: + key_comp() const { return (value_compare(_comp).comp); } +// value_comp -------------------------------- +MP_TPL typename MP::value_compare MP:: + value_comp() const { return (value_compare(_comp)); } + + + /************** + * operations : + **************/ +// find -------------------------------------- +MP_TPL typename MP::iterator MP:: + find (const key_type& k) { return (_bst.find(k)); } +MP_TPL typename MP::const_iterator MP:: + find (const key_type& k) const { return (_bst.find(k)); } +// count ------------------------------------- +MP_TPL typename MP::size_type MP:: + count (const key_type& k) const { return (_bst.count(k)); } +// lower_bound ------------------------------- +MP_TPL typename MP::iterator MP:: + lower_bound (const key_type& k) { + + iterator it = begin(); + iterator it_end = end(); + + while (it != it_end) + { + if (_comp(it->first, k) == false) + return (it); + ++it; + } + return (it_end); +} +MP_TPL typename MP::const_iterator MP:: + lower_bound (const key_type& k) const { + + const_iterator it = begin(); + const_iterator it_end = end(); + + while (it != it_end) + { + if (_comp(it->first, k) == false) + return (it); + ++it; + } + return (it_end); +} +// upper_bound ------------------------------- +MP_TPL typename MP::iterator MP:: + upper_bound (const key_type& k) { + + iterator it = begin(); + iterator it_end = end(); + + while (it != it_end) + { + if (_comp(k, it->first)) + return (it); + ++it; + } + return (it_end); +} +MP_TPL typename MP::const_iterator MP:: + upper_bound (const key_type& k) const { + + const_iterator it = begin(); + const_iterator it_end = end(); + + while (it != it_end) + { + if (_comp(k, it->first)) + return (it); + ++it; + } + return (it_end); +} +// equal_range ------------------------------- +MP_TPL pair MP:: + equal_range (const key_type& k) const { + + return ft::make_pair( lower_bound(k), upper_bound(k) ); +} +MP_TPL pair MP:: + equal_range (const key_type& k) { + + return ft::make_pair( lower_bound(k), upper_bound(k) ); +} + + + /************* + * allocator : + *************/ +// get_allocator ----------------------------- +MP_TPL typename MP::allocator_type MP:: + get_allocator() const { return (_allocator); } + + + /************************ + * non-member functions : + ************************/ +// operator == ------------------------------- +template< class Key, class T, class Compare, class Alloc > bool operator== + ( const MP& lhs, const MP& rhs ) { + + return (lhs._bst == rhs._bst); +} +// operator < -------------------------------- +template< class Key, class T, class Compare, class Alloc > bool operator< + ( const MP& lhs, const MP& rhs ) { + + return (lhs._bst < rhs._bst); +} +// operator != ------------------------------- +template< class Key, class T, class Compare, class Alloc > bool operator!= + ( const MP& lhs, const MP& rhs ) { return !(lhs == rhs); } +// operator <= ------------------------------- +template< class Key, class T, class Compare, class Alloc > bool operator<= + ( const MP& lhs, const MP& rhs ) { return !(lhs > rhs); } +// operator > -------------------------------- +template< class Key, class T, class Compare, class Alloc > bool operator> + ( const MP& lhs, const MP& rhs ) { return (rhs < lhs); } +// operator >= ------------------------------- +template< class Key, class T, class Compare, class Alloc > bool operator>= + ( const MP& lhs, const MP& rhs ) { return !(lhs < rhs); } +// swap (map) ----------------------------- +template< class Key, class T, class Compare, class Alloc > void swap + ( const MP& lhs, const MP& rhs ) { lhs.swap(rhs); } + +} // namespace ft + +#undef VT +#undef VT_TPL + diff --git a/templates/bst.tpp b/templates/bst.tpp deleted file mode 100644 index 77a5f5a..0000000 --- a/templates/bst.tpp +++ /dev/null @@ -1,628 +0,0 @@ - -#define BST_TEMPLATE template < typename Key, typename T, typename Compare, typename Allocator > -#define BST map - -namespace ft { - - - ////////////////////// - // Member functions // - -BST_TEMPLATE -BST:: - map(const Compare& comp, const Allocator& alloc) : -_size(0), -_root(NULL), -_comp(comp), -_allocator(alloc) -{ - _init_sentinel(); -} - -BST_TEMPLATE -template < typename InputIt > -BST:: - map(InputIt first, InputIt last, const Compare& comp, const Allocator& alloc) : -_size(0), -_root(NULL), -_comp(comp), -_allocator(alloc) -{ - _init_sentinel(); - insert(first, last); -} - -BST_TEMPLATE -BST:: - map(const map& src) : -_size(0), -_root(NULL), -_comp(src._comp), -_allocator(src._allocator) -{ - _init_sentinel(); - *this = src; -} - -BST_TEMPLATE -BST:: - ~map() -{ - clear(); - _allocator_node_sentinel.destroy(_sentinel); - _allocator_node_sentinel.deallocate(_sentinel, 1); -} - -BST_TEMPLATE -BST& BST:: - operator=(const map& rhs) -{ - if (this == &rhs) - return (*this); - map new_bst(rhs.begin(), rhs.end()); - swap(new_bst); - return (*this); -} - - - //////////////////// - // Element access // - -BST_TEMPLATE -T& BST:: - operator[](const Key& key) -{ - node* n = _root; - //node* prev = NULL; - - while (n) - { - //prev = n; - if (_comp(key, n->value.first)) - n = n->left; - else if (_comp(n->value.first, key)) - n = n->right; - else - return (n->value.second); - } - - // TODO : Call insert with hint (prev) - n = insert( ft::make_pair(key, mapped_type()) ).first.getNode(); - - return (n->value.second); -} - - - /////////////// - // Iterators // - -BST_TEMPLATE -typename BST::iterator BST:: - begin() -{ - if (_root) - return iterator(_root->min(), _sentinel); - else - return end(); -} - -BST_TEMPLATE -typename BST::const_iterator BST:: - begin() const -{ - if (_root) - return const_iterator(_root->min(), _sentinel); - else - return end(); -} - -BST_TEMPLATE -typename BST::iterator BST:: - end() { return iterator(NULL, _sentinel); } - -BST_TEMPLATE -typename BST::const_iterator BST:: - end() const { return const_iterator(NULL, _sentinel); } - -BST_TEMPLATE -typename BST::reverse_iterator BST:: - rbegin() { return reverse_iterator(end()); } - -BST_TEMPLATE -typename BST::const_reverse_iterator BST:: - rbegin() const { return const_reverse_iterator(end()); } - -BST_TEMPLATE -typename BST::reverse_iterator BST:: - rend() { return reverse_iterator(begin()); } - -BST_TEMPLATE -typename BST::const_reverse_iterator BST:: - rend() const { return const_reverse_iterator(begin()); } - - - ////////////// - // Capacity // - -BST_TEMPLATE -bool BST:: - empty() const { return (_size == 0); } - -BST_TEMPLATE -typename BST::size_type BST:: - size() const { return (_size); } - -BST_TEMPLATE -typename BST::size_type BST:: - max_size() const -{ - return ( _allocator_node.max_size() ); -} - - - /////////////// - // Modifiers // - -BST_TEMPLATE -void BST:: - clear() -{ - // TODO : optimisation jouable ? - erase(begin(), end()); - //_size = 0; -} - -BST_TEMPLATE -pair BST:: - insert(const value_type& value) -{ - pair ret; - - ret = _insert(value); - if (ret.second == true) - _insert_rebalancing(ret.first.getNode()->up); - return (ret); -} - -BST_TEMPLATE -typename BST::iterator BST:: - insert(iterator hint, const value_type& value) -{ - // TODO : optimise with hint - (void)hint; - return insert(value).first; -} - -BST_TEMPLATE -template < typename InputIt > -void BST:: - insert(InputIt first, InputIt last) -{ - //static int i = 0; // Debug - while (first != last) - { - insert(*first); - ++first; - //std::cout << "c|" << i << "\n"; - //++i; - } -} - -BST_TEMPLATE -void BST:: - erase(iterator pos) -{ - node* delete_point; - delete_point = _erase(pos); - _erase_rebalancing(delete_point); -} - -BST_TEMPLATE -void BST:: - erase(iterator first, iterator last) -{ - while (first != last) - erase(first++); -} - -BST_TEMPLATE -typename BST::size_type BST:: - erase(const Key& key) -{ - iterator pos = find(key); - if (pos == end()) - return (0); - else - { - erase(pos); - return (1); - } -} - -BST_TEMPLATE -void BST:: - swap(map& other) -{ - node* tmp_root = _root; - node_sentinel* tmp_sentinel = _sentinel; - size_type tmp_size = _size; - - _root = other._root; - _sentinel = other._sentinel; - _size = other._size; - - other._root = tmp_root; - other._sentinel = tmp_sentinel; - other._size = tmp_size; -} - - - //////////// - // Lookup // - -BST_TEMPLATE -typename BST::iterator BST:: - find(const Key& key) -{ - node* n = _root; - - while (n) - { - if (_comp(key, n->value.first)) - n = n->left; - else if (_comp(n->value.first, key)) - n = n->right; - else - return (iterator(n, _sentinel)); - } - return (end()); -} - -BST_TEMPLATE -typename BST::const_iterator BST:: - find(const Key& key) const -{ - node* n = _root; - - while (n) - { - if (_comp(key, n->value.first)) - n = n->left; - else if (_comp(n->value.first, key)) - n = n->right; - else - return (const_iterator(n, _sentinel)); - } - return (end()); -} - -BST_TEMPLATE -typename BST::size_type BST:: - count(const Key& key) const -{ - if (find(key) != end()) - return (1); - else - return (0); -} - - - /////////////////////// - // Private functions // - -BST_TEMPLATE -void BST:: - _init_sentinel() -{ - _sentinel = _allocator_node_sentinel.allocate(1); - _allocator_node_sentinel.construct(_sentinel, node_sentinel()); -} - -BST_TEMPLATE -pair BST:: - _insert(const value_type& value) -{ - node* n = _root; - node* prev = NULL; - - while (n) - { - prev = n; - if (_comp(value.first, n->value.first)) - n = n->left; - else if (_comp(n->value.first, value.first)) - n = n->right; - else - return ft::make_pair(iterator(n, _sentinel), false); - } - - n = _allocator_node.allocate(1); - _allocator_node.construct(n, node(value)); - if (_root == NULL) // if (_size == 0) - { - _root = n; - _sentinel->child = _root; - } - else if (_comp(value.first, prev->value.first)) - prev->left = n; - else - prev->right = n; - n->up = prev; - ++_size; - return ft::make_pair(iterator(n, _sentinel), true); -} - -BST_TEMPLATE -node* BST:: - _erase(iterator pos) -{ - node* n = pos.getNode(); - node* delete_point = NULL; - - if (n->left && n->right) // 2 child - { - node* next = n->right->min(); - - if (next->up != n) - { - _subtree_shift(next, next->right); - next->right = n->right; - next->right->up = next; - } - delete_point = _subtree_shift(n, next); - next->left = n->left; - next->left->up = next; - } - else if (!n->left && !n->right) // no child (leaf) - delete_point = _subtree_shift(n, NULL); // bug ? - else if (n->left) // 1 child - delete_point = _subtree_shift(n, n->left); - else if (n->right) // 1 child - delete_point = _subtree_shift(n, n->right); // bug ? - - _allocator_node.destroy(n); - _allocator_node.deallocate(n, 1); - --_size; - return (delete_point); -} - -BST_TEMPLATE -node* BST:: - _subtree_shift(node* st_old, node* st_new) -{ - node* p = st_old->up; - - if (st_old == _root) - { - _root = st_new; - _sentinel->child = _root; - } - else if (st_old == p->left) - p->left = st_new; - else - p->right = st_new; - - if (st_new == NULL) - return (p); // return deletion point - st_new->up = p; - return (st_new); // return deletion point -} - -BST_TEMPLATE -void BST:: - _insert_rebalancing(node* n) -{ - node* old_n; - node* parent = NULL; - - while (n) - { - n->height = _compute_height(n); - - if (_bf(n) > 1) // Left Heavy - { - parent = n->up; - if (_bf(n->left) < 0) // Left-Right Case (BF == -1) - n->left = _rotate_left(n->left); - // Left-Left Case - n = _rotate_right(n); - old_n = n->right; - } - else if (_bf(n) < -1) // Right Heavy - { - parent = n->up; - if (_bf(n->right) > 0) // Right-Left Case (BF == 1) - n->right = _rotate_right(n->right); - // Right-Right Case - n = _rotate_left(n); - old_n = n->left; - } - - if (parent) - { - if (parent->left == old_n) - parent->left = n; - else - parent->right = n; - break; - } - - n = n->up; - } - - while (n) - { - n->height = _compute_height(n); - n = n->up; - } -} - -BST_TEMPLATE -void BST:: - _erase_rebalancing(node* n) -{ - node* old_n; - node* parent = NULL; - - while (n) - { - n->height = _compute_height(n); - - if (_bf(n) > 1) // Left Heavy - { - parent = n->up; - if (_bf(n->left) < 0) // Left-Right Case (BF == -1) - n->left = _rotate_left(n->left); - // Left-Left Case - n = _rotate_right(n); - old_n = n->right; - } - else if (_bf(n) < -1) // Right Heavy - { - parent = n->up; - if (_bf(n->right) > 0) // Right-Left Case (BF == 1) - n->right = _rotate_right(n->right); - // Right-Right Case - n = _rotate_left(n); - old_n = n->left; - } - - if (parent) - { - if (parent->left == old_n) - parent->left = n; - else - parent->right = n; - parent = NULL; - } - - n = n->up; - } -} - -BST_TEMPLATE -short BST:: - _compute_height(node* n) -{ - if (n->left && n->right) - return std::max(n->left->height, n->right->height) + 1; - else if (n->left) - return n->left->height + 1; - else if (n->right) - return n->right->height + 1; - else - return 1; -} - -BST_TEMPLATE -short BST:: - _bf(node* n) // optimisation possible if assume n have at least one child ? -{ - if (n->left && n->right) - return n->left->height - n->right->height; - else if (n->left) - return n->left->height; - else if (n->right) - return (-(n->right->height)); - else - return 0; -} - -BST_TEMPLATE -node* BST:: - _rotate_left(node* n) // assume n->right != NULL -{ - node* ori_right = n->right; - - ori_right->up = n->up; - n->up = ori_right; - - n->right = ori_right->left; - if (n->right != NULL) - n->right->up = n; - ori_right->left = n; - - n->height = _compute_height(n); - ori_right->height = _compute_height(ori_right); - - if (n == _root) - { - _root = ori_right; - _sentinel->child = _root; - } - - return ori_right; // return new sub-tree root -} - -BST_TEMPLATE -node* BST:: - _rotate_right(node* n) // assume n->left != NULL -{ - node* ori_left = n->left; - - ori_left->up = n->up; - n->up = ori_left; - - n->left = ori_left->right; - if (n->left != NULL) - n->left->up = n; - ori_left->right = n; - - n->height = _compute_height(n); - ori_left->height = _compute_height(ori_left); - - if (n == _root) - { - _root = ori_left; - _sentinel->child = _root; - } - - return ori_left; // return new sub-tree root -} - - - ////////////////////////// - // Non-member functions // - -BST_TEMPLATE -bool operator==(const BST& lhs, const BST& rhs) -{ - if (lhs.size() != rhs.size()) - return false; - return ft::equal(lhs.begin(), lhs.end(), rhs.begin()); -} - -BST_TEMPLATE -bool operator!=(const BST& lhs, const BST& rhs) - { return !(lhs == rhs); } - - -BST_TEMPLATE -bool operator<(const BST& lhs, const BST& rhs) -{ - return ft::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); -} - -BST_TEMPLATE -bool operator>(const BST& lhs, const BST& rhs) - { return (rhs < lhs); } - -BST_TEMPLATE -bool operator<=(const BST& lhs, const BST& rhs) - { return !(lhs > rhs); } - -BST_TEMPLATE -bool operator>=(const BST& lhs, const BST& rhs) - { return !(lhs < rhs); } - - -BST_TEMPLATE -void swap(BST& lhs, BST& rhs) - { lhs.swap(rhs); } - - -} // namespace ft - -#undef BST -#undef BST_TEMPLATE - diff --git a/templates/map.tpp b/templates/map.tpp index 354fa0f..33e9a9e 100644 --- a/templates/map.tpp +++ b/templates/map.tpp @@ -1,8 +1,6 @@ - -#define MP_TPL template < typename Key, typename T, typename Compare, typename Alloc > -#define MP map - +#define MP_TPL template < typename Key, typename T, typename Compare, typename Allocator > +#define MP map namespace ft { @@ -13,38 +11,49 @@ namespace ft { // constructors ------------------------------ MP_TPL MP:: map (const key_compare & comp, const allocator_type & alloc) - : _bst() - , _allocator(alloc) - , _comp(comp) { + : _size(0) + , _root(NULL) + , _comp(comp) + , _allocator(alloc) { - return; + _init_sentinel(); } -MP_TPL template MP:: +MP_TPL template < typename InputIt > MP:: map (InputIt first, InputIt last, const key_compare& comp, const allocator_type& alloc) - : _bst(first, last) - , _allocator(alloc) - , _comp(comp) { + : _size(0) + , _root(NULL) + , _comp(comp) + , _allocator(alloc) { + + _init_sentinel(); + insert(first, last); } MP_TPL MP:: - map (const map& x) - : _bst() - , _allocator(x._allocator) - , _comp(x._comp) { + map(const map& src) + : _size(0) + , _root(NULL) + , _comp(src._comp) + , _allocator(src._allocator) { - *this = x; + _init_sentinel(); + *this = src; } // destructor -------------------------------- MP_TPL MP:: - ~map() { clear(); } + ~map() { + + clear(); + _allocator_node_sentinel.destroy(_sentinel); + _allocator_node_sentinel.deallocate(_sentinel, 1); +} // operator= --------------------------------- MP_TPL MP& MP:: - operator= (const map& x) { + operator=(const map& rhs) { - if (this == &x) + if (this == &rhs) return (*this); - - map new_map(x.begin(), x.end()); - swap(new_map); + map new_bst(rhs.begin(), rhs.end()); + swap(new_bst); return (*this); } @@ -54,38 +63,50 @@ MP_TPL MP& MP:: *************/ // begin ------------------------------------- MP_TPL typename MP::iterator MP:: - begin() { return (_bst.begin()); } + begin() { + + if (_root) + return iterator(_root->min(), _sentinel); + else + return end(); +} MP_TPL typename MP::const_iterator MP:: - begin() const { return (_bst.begin()); } + begin() const { + + if (_root) + return const_iterator(_root->min(), _sentinel); + else + return end(); +} // end --------------------------------------- MP_TPL typename MP::iterator MP:: - end() { return (_bst.end()); } + end() { return iterator(NULL, _sentinel); } MP_TPL typename MP::const_iterator MP:: - end() const { return (_bst.end()); } + end() const { return const_iterator(NULL, _sentinel); } // rbegin ------------------------------------ MP_TPL typename MP::reverse_iterator MP:: - rbegin() { return (_bst.rbegin()); } + rbegin() { return reverse_iterator(end()); } MP_TPL typename MP::const_reverse_iterator MP:: - rbegin() const { return (_bst.rbegin()); } + rbegin() const { return const_reverse_iterator(end()); } // rend -------------------------------------- MP_TPL typename MP::reverse_iterator MP:: - rend() { return (_bst.rend()); } + rend() { return reverse_iterator(begin()); } MP_TPL typename MP::const_reverse_iterator MP:: - rend() const { return (_bst.rend()); } + rend() const { return const_reverse_iterator(begin()); } /************ * capacity : ************/ // empty ------------------------------------- -MP_TPL bool MP:: - empty() const { return (_bst.empty()); } +MP_TPL bool MP:: + empty() const { return (_size == 0); } // size -------------------------------------- MP_TPL typename MP::size_type MP:: - size() const { return (_bst.size()); } + size() const { return (_size); } // max_size ---------------------------------- MP_TPL typename MP::size_type MP:: - max_size() const { return (_bst.max_size()); } + max_size() const { return ( _allocator_node.max_size() ); } /****************** @@ -93,7 +114,24 @@ MP_TPL typename MP::size_type MP:: ******************/ // operator[] -------------------------------- MP_TPL typename MP::mapped_type& MP:: - operator[] (const key_type& k) { return _bst[k]; } + operator[](const Key& key) { + + node* n = _root; + + while (n) + { + if (_comp(key, n->value.first)) + n = n->left; + else if (_comp(n->value.first, key)) + n = n->right; + else + return (n->value.second); + } + + n = insert( ft::make_pair(key, mapped_type()) ).first.getNode(); + + return (n->value.second); +} /************* @@ -101,35 +139,75 @@ MP_TPL typename MP::mapped_type& MP:: *************/ // insert ------------------------------------ MP_TPL pair MP:: - insert (const value_type& val) { return (_bst.insert(val)); } + insert(const value_type& value) { + + pair ret; + + ret = _insert(value); + if (ret.second == true) + _insert_rebalancing(ret.first.getNode()->up); + return (ret); +} MP_TPL typename MP::iterator MP:: - insert (iterator pos, const value_type& val) { return (_bst.insert(pos, val)); } -MP_TPL template void MP:: - insert (InputIt first, InputIt last) { return (_bst.insert(first, last)); } + insert(iterator hint, const value_type& value) { + + (void)hint; + return insert(value).first; +} +MP_TPL template < typename InputIt > void MP:: + insert(InputIt first, InputIt last) { + + while (first != last) + { + insert(*first); + ++first; + } +} // erase ------------------------------------- MP_TPL void MP:: - erase (iterator pos) { return (_bst.erase(pos)); } -MP_TPL typename MP::size_type MP:: - erase (const key_type& k) { return (_bst.erase(k)); } + erase(iterator pos) { + + node* delete_point; + delete_point = _erase(pos); + _erase_rebalancing(delete_point); +} MP_TPL void MP:: - erase (iterator first, iterator last) { return (_bst.erase(first, last)); } + erase(iterator first, iterator last) { + + while (first != last) + erase(first++); +} +MP_TPL typename MP::size_type MP:: + erase(const Key& key) { + + iterator pos = find(key); + if (pos == end()) + return (0); + else + { + erase(pos); + return (1); + } +} // swap -------------------------------------- MP_TPL void MP:: - swap (map& x) { + swap(map& other) { - bst_map tmp; + node* tmp_root = _root; + node_sentinel* tmp_sentinel = _sentinel; + size_type tmp_size = _size; - tmp.swap(_bst); - _bst.swap(x._bst); - x._bst.swap(tmp); + _root = other._root; + _sentinel = other._sentinel; + _size = other._size; + + other._root = tmp_root; + other._sentinel = tmp_sentinel; + other._size = tmp_size; } - // clear ------------------------------------- MP_TPL void MP:: - clear() { - - _bst.clear(); -} + clear() { erase(begin(), end()); } /************* @@ -148,12 +226,46 @@ MP_TPL typename MP::value_compare MP:: **************/ // find -------------------------------------- MP_TPL typename MP::iterator MP:: - find (const key_type& k) { return (_bst.find(k)); } + find(const Key& key) { + + node* n = _root; + + while (n) + { + if (_comp(key, n->value.first)) + n = n->left; + else if (_comp(n->value.first, key)) + n = n->right; + else + return (iterator(n, _sentinel)); + } + return (end()); +} MP_TPL typename MP::const_iterator MP:: - find (const key_type& k) const { return (_bst.find(k)); } + find(const Key& key) const { + + node* n = _root; + + while (n) + { + if (_comp(key, n->value.first)) + n = n->left; + else if (_comp(n->value.first, key)) + n = n->right; + else + return (const_iterator(n, _sentinel)); + } + return (end()); +} // count ------------------------------------- MP_TPL typename MP::size_type MP:: - count (const key_type& k) const { return (_bst.count(k)); } + count(const Key& key) const { + + if (find(key) != end()) + return (1); + else + return (0); +} // lower_bound ------------------------------- MP_TPL typename MP::iterator MP:: lower_bound (const key_type& k) { @@ -233,39 +345,300 @@ MP_TPL typename MP::allocator_type MP:: get_allocator() const { return (_allocator); } + /********************* + * private functions : + *********************/ +MP_TPL void MP:: + _init_sentinel() { + + _sentinel = _allocator_node_sentinel.allocate(1); + _allocator_node_sentinel.construct(_sentinel, node_sentinel()); +} +MP_TPL pair MP:: + _insert(const value_type& value) { + + node* n = _root; + node* prev = NULL; + + while (n) + { + prev = n; + if (_comp(value.first, n->value.first)) + n = n->left; + else if (_comp(n->value.first, value.first)) + n = n->right; + else + return ft::make_pair(iterator(n, _sentinel), false); + } + + n = _allocator_node.allocate(1); + _allocator_node.construct(n, node(value)); + if (_root == NULL) + { + _root = n; + _sentinel->child = _root; + } + else if (_comp(value.first, prev->value.first)) + prev->left = n; + else + prev->right = n; + n->up = prev; + ++_size; + return ft::make_pair(iterator(n, _sentinel), true); +} +MP_TPL node* MP:: + _erase(iterator pos) { + + node* n = pos.getNode(); + node* delete_point = NULL; + + if (n->left && n->right) + { + node* next = n->right->min(); + + if (next->up != n) + { + _subtree_shift(next, next->right); + next->right = n->right; + next->right->up = next; + } + delete_point = _subtree_shift(n, next); + next->left = n->left; + next->left->up = next; + } + else if (!n->left && !n->right) + delete_point = _subtree_shift(n, NULL); + else if (n->left) + delete_point = _subtree_shift(n, n->left); + else if (n->right) + delete_point = _subtree_shift(n, n->right); + + _allocator_node.destroy(n); + _allocator_node.deallocate(n, 1); + --_size; + return (delete_point); +} +MP_TPL node* MP:: + _subtree_shift(node* st_old, node* st_new) { + + node* p = st_old->up; + + if (st_old == _root) + { + _root = st_new; + _sentinel->child = _root; + } + else if (st_old == p->left) + p->left = st_new; + else + p->right = st_new; + + if (st_new == NULL) + return (p); + st_new->up = p; + return (st_new); +} +MP_TPL void MP:: + _insert_rebalancing(node* n) { + + node* old_n; + node* parent = NULL; + + while (n) + { + n->height = _compute_height(n); + + if (_balance_factor(n) > 1) // Left Heavy + { + parent = n->up; + if (_balance_factor(n->left) < 0) // Left-Right Case + n->left = _rotate_left(n->left); + // Left-Left Case + n = _rotate_right(n); + old_n = n->right; + } + else if (_balance_factor(n) < -1) // Right Heavy + { + parent = n->up; + if (_balance_factor(n->right) > 0) // Right-Left Case + n->right = _rotate_right(n->right); + // Right-Right Case + n = _rotate_left(n); + old_n = n->left; + } + + if (parent) + { + if (parent->left == old_n) + parent->left = n; + else + parent->right = n; + break; + } + + n = n->up; + } + + while (n) + { + n->height = _compute_height(n); + n = n->up; + } +} +MP_TPL void MP:: + _erase_rebalancing(node* n) { + + node* old_n; + node* parent = NULL; + + while (n) + { + n->height = _compute_height(n); + + if (_balance_factor(n) > 1) // Left Heavy + { + parent = n->up; + if (_balance_factor(n->left) < 0) // Left-Right Case (BF == -1) + n->left = _rotate_left(n->left); + // Left-Left Case + n = _rotate_right(n); + old_n = n->right; + } + else if (_balance_factor(n) < -1) // Right Heavy + { + parent = n->up; + if (_balance_factor(n->right) > 0) // Right-Left Case (BF == 1) + n->right = _rotate_right(n->right); + // Right-Right Case + n = _rotate_left(n); + old_n = n->left; + } + + if (parent) + { + if (parent->left == old_n) + parent->left = n; + else + parent->right = n; + parent = NULL; + } + + n = n->up; + } +} +MP_TPL short MP:: + _compute_height(node* n) { + + if (n->left && n->right) + return std::max(n->left->height, n->right->height) + 1; + else if (n->left) + return n->left->height + 1; + else if (n->right) + return n->right->height + 1; + else + return 1; +} +MP_TPL short MP:: + _balance_factor(node* n) { + + if (n->left && n->right) + return n->left->height - n->right->height; + else if (n->left) + return n->left->height; + else if (n->right) + return (-(n->right->height)); + else + return 0; +} +MP_TPL node* MP:: + _rotate_left(node* n) { + + node* ori_right = n->right; + + ori_right->up = n->up; + n->up = ori_right; + + n->right = ori_right->left; + if (n->right != NULL) + n->right->up = n; + ori_right->left = n; + + n->height = _compute_height(n); + ori_right->height = _compute_height(ori_right); + + if (n == _root) + { + _root = ori_right; + _sentinel->child = _root; + } + + return ori_right; +} +MP_TPL node* MP:: + _rotate_right(node* n) { + + node* ori_left = n->left; + + ori_left->up = n->up; + n->up = ori_left; + + n->left = ori_left->right; + if (n->left != NULL) + n->left->up = n; + ori_left->right = n; + + n->height = _compute_height(n); + ori_left->height = _compute_height(ori_left); + + if (n == _root) + { + _root = ori_left; + _sentinel->child = _root; + } + + return ori_left; +} + + /************************ * non-member functions : ************************/ // operator == ------------------------------- -template< class Key, class T, class Compare, class Alloc > bool operator== - ( const MP& lhs, const MP& rhs ) { - - return (lhs._bst == rhs._bst); +MP_TPL bool operator== (const MP& lhs, const MP& rhs) { + + if (lhs.size() != rhs.size()) + return false; + return ft::equal(lhs.begin(), lhs.end(), rhs.begin()); } // operator < -------------------------------- -template< class Key, class T, class Compare, class Alloc > bool operator< - ( const MP& lhs, const MP& rhs ) { - - return (lhs._bst < rhs._bst); +MP_TPL bool operator< (const MP& lhs, const MP& rhs) { + + return ft::lexicographical_compare( + lhs.begin(), + lhs.end(), + rhs.begin(), + rhs.end() + ); } // operator != ------------------------------- -template< class Key, class T, class Compare, class Alloc > bool operator!= - ( const MP& lhs, const MP& rhs ) { return !(lhs == rhs); } +MP_TPL bool operator!= (const MP& lhs, const MP& rhs) { + return !(lhs == rhs); } // operator <= ------------------------------- -template< class Key, class T, class Compare, class Alloc > bool operator<= - ( const MP& lhs, const MP& rhs ) { return !(lhs > rhs); } +MP_TPL bool operator<= (const MP& lhs, const MP& rhs) { + return !(lhs > rhs); } // operator > -------------------------------- -template< class Key, class T, class Compare, class Alloc > bool operator> - ( const MP& lhs, const MP& rhs ) { return (rhs < lhs); } +MP_TPL bool operator> (const MP& lhs, const MP& rhs) { + return (rhs < lhs); } // operator >= ------------------------------- -template< class Key, class T, class Compare, class Alloc > bool operator>= - ( const MP& lhs, const MP& rhs ) { return !(lhs < rhs); } +MP_TPL bool operator>= (const MP& lhs, const MP& rhs) { + return !(lhs < rhs); } // swap (map) ----------------------------- -template< class Key, class T, class Compare, class Alloc > void swap - ( const MP& lhs, const MP& rhs ) { lhs.swap(rhs); } +MP_TPL void swap(MP& lhs, MP& rhs) { + lhs.swap(rhs); } + } // namespace ft -#undef VT -#undef VT_TPL +#undef MP +#undef MP_TPL diff --git a/tests/includes/main.hpp b/tests/includes/main.hpp index d9d8da6..abdfde7 100644 --- a/tests/includes/main.hpp +++ b/tests/includes/main.hpp @@ -71,7 +71,8 @@ void tests_map_equal_range(); void tests_map_get_allocator(); void tests_map_relational_operators(); void tests_map_swap_non_member(); - +// stack +void tests_stack_constructor(); #endif diff --git a/tests/includes/tests_mutant_stack.hpp b/tests/includes/tests_mutant_stack.hpp new file mode 100644 index 0000000..53461ca --- /dev/null +++ b/tests/includes/tests_mutant_stack.hpp @@ -0,0 +1,22 @@ + +#ifndef TESTS_MUTANT_STACK_HPP +# define TESTS_MUTANT_STACK_HPP + +#include + +template +class MutantStack : public std::stack { + +public: + + typedef typename std::stack::container_type::iterator iterator; + typedef typename std::stack::container_type::const_iterator const_iterator; + + iterator begin() {return this->c.begin();} + iterator end() {return this->c.end();} + const_iterator begin() const {return this->c.begin();} + const_iterator end() const {return this->c.end();} +}; + +#endif + diff --git a/tests/includes/tests_utils.hpp b/tests/includes/tests_utils.hpp index bed6a71..7dc0d4c 100644 --- a/tests/includes/tests_utils.hpp +++ b/tests/includes/tests_utils.hpp @@ -10,17 +10,20 @@ #include // std::reverse_iterator #include // std::make_pair #include // std::stringstream +#include // toogle between test ft and stl // ************************* #include #include +#include #ifdef STL namespace ft = std; #else #include "vector.hpp" #include "map.hpp" + #include "stack.hpp" #include "reverse_iterator.hpp" #endif @@ -66,15 +69,18 @@ extern std::vector< mystruct* > mem_list; // adding each test to the list // *************************** +#define TEST(f_name) TEST_V(f_name) +/* + add_to_list(#f_name, "char", new(s_ ## f_name ));\ + add_to_list(#f_name, "std::string", new(s_ ## f_name ));\ + add_to_list(#f_name, "mystruct*", new(s_ ## f_name ));\ +*/ #define TEST_V(f_name) \ template struct s_ ## f_name : public A_test\ { void func(); };\ void f_name () {\ add_to_list("", "", NULL);\ add_to_list(#f_name, "int", new(s_ ## f_name ));\ - add_to_list(#f_name, "char", new(s_ ## f_name ));\ - add_to_list(#f_name, "std::string", new(s_ ## f_name ));\ - add_to_list(#f_name, "mystruct*", new(s_ ## f_name ));\ }\ template \ void s_ ## f_name ::func() @@ -84,13 +90,6 @@ extern std::vector< mystruct* > mem_list; { void func(); };\ void f_name () {\ add_to_list("", "", NULL);\ - add_to_list(#f_name, "char, mystruct*", new(s_ ## f_name ));\ - add_to_list(#f_name, "int, mystruct*", new(s_ ## f_name ));\ - }\ - template \ - void s_ ## f_name ::func() - -/* add_to_list(#f_name, "char, int", new(s_ ## f_name ));\ add_to_list(#f_name, "char, char", new(s_ ## f_name ));\ add_to_list(#f_name, "char, std::string", new(s_ ## f_name ));\ @@ -99,12 +98,17 @@ extern std::vector< mystruct* > mem_list; add_to_list(#f_name, "int, char", new(s_ ## f_name ));\ add_to_list(#f_name, "int, std::string", new(s_ ## f_name ));\ add_to_list(#f_name, "int, mystruct*", new(s_ ## f_name ));\ + }\ + template \ + void s_ ## f_name ::func() + +/* */ // templates print // ***************************************** template - void print(ft::vector vec, std::string name) { + void print(ft::vector& vec, std::string name) { int i = 0; typename ft::vector::iterator it; @@ -116,7 +120,7 @@ template std::cout << "\nsize:" << vec.size() << " capacty:" << vec.capacity() << "\n"; } template - void print(ft::map mp, std::string name) { + void print(ft::map& mp, std::string name) { int i = 0; typename ft::map::iterator it; @@ -127,6 +131,14 @@ template std::cout << "[" << i << "]" << it->first << ":" << it->second << " "; std::cout << "\nsize:" << mp.size() << "\n"; } +template + void print(ft::stack& st, std::string name) { + + std::cout << "\n" << name << ":(map)\n"; + for (int i = st.size(); i > 0 ; i--, st.pop()) + std::cout << "[" << i << "]" << st.top() << " "; + std::cout << "\nsize:" << st.size() << "\n"; +} // templates get value // ************************************* diff --git a/tests/main.cpp b/tests/main.cpp index b5696e7..5f27d3c 100644 --- a/tests/main.cpp +++ b/tests/main.cpp @@ -1,7 +1,6 @@ #include "main.hpp" - int main() { // VECTOR @@ -34,35 +33,35 @@ int main() { // tests_vector_reverse_iterators(); // MAP - tests_map_simple(); - tests_map_constructor(); - tests_map_operator_assignation(); - tests_map_begin(); - tests_map_end(); - tests_map_rbegin(); - tests_map_rend(); - tests_map_empty(); - tests_map_size(); - tests_map_max_size(); - tests_map_operator_access(); - tests_map_insert(); - tests_map_erase(); - tests_map_swap(); - tests_map_clear(); +// tests_map_simple(); +// tests_map_constructor(); +// tests_map_operator_assignation(); +// tests_map_begin(); +// tests_map_end(); +// tests_map_rbegin(); +// tests_map_rend(); +// tests_map_empty(); +// tests_map_size(); +// tests_map_max_size(); +// tests_map_operator_access(); +// tests_map_insert(); +// tests_map_erase(); +// tests_map_swap(); +// tests_map_clear(); // tests_map_key_comp(); // tests_map_value_comp(); - tests_map_find(); - tests_map_count(); +// tests_map_find(); +// tests_map_count(); // tests_map_lower_bound(); // tests_map_upper_bound(); // tests_map_equal_range(); // tests_map_get_allocator(); // tests_map_relational_operators(); - tests_map_swap_non_member(); +// tests_map_swap_non_member(); // STACK -// tests_stack_constructor(); + tests_stack_constructor(); // tests_stack_operator_assignation(); // tests_stack_begin(); // tests_stack_end(); diff --git a/tests/main_map_1.cpp b/tests/main_map_1.cpp new file mode 100644 index 0000000..6d4019a --- /dev/null +++ b/tests/main_map_1.cpp @@ -0,0 +1,741 @@ + +#include +#include +#include // std::setw() +#include // std::reverse_iterator +#include // std::make_pair +#include // std::stringstream +#include +#include + +// toogle ft in stl +#ifdef STL + namespace ft = std; +#else + #include "map.hpp" + #include "reverse_iterator.hpp" +#endif + +// defines +# define TEST_M(s) template void s () +# define TITLE(s) std::cout << "\n" B_PURPLE #s RESET "\n\n"; +# define VALT(n) val(n) +# define VALU(n) val(n) +# define TOI(n) toi(n) +# define PRINT(n) print<>(n, #n); +# define DELETE delete_structs(); + +// colors +# define GRAY "\e[0;30m" +# define RED "\e[0;31m" +# define GREEN "\e[0;32m" +# define YELLOW "\e[0;33m" +# define BLUE "\e[0;34m" +# define PURPLE "\e[0;35m" +# define CYAN "\e[0;36m" +# define WHITE "\e[0;37m" + +# define B_GRAY "\e[1;30m" +# define B_RED "\e[1;31m" +# define B_GREEN "\e[1;32m" +# define B_YELLOW "\e[1;33m" +# define B_BLUE "\e[1;34m" +# define B_PURPLE "\e[1;35m" +# define B_CYAN "\e[1;36m" +# define B_WHITE "\e[1;37m" + +# define RESET "\e[0m" + +// mystruct declaration +struct mystruct { +public: + mystruct(int data = 0); + ~mystruct(); + int * get_data() const; +private: + int * _val; +}; +std::ostream & operator<<(std::ostream & o, mystruct const * rhs); + +// mystruct definition +mystruct::mystruct(int data) + {_val = new int[2]; _val[0] = data; _val[1] = data;} +mystruct::~mystruct() + {delete[] _val;} +int * mystruct::get_data() const + {return _val;} +std::ostream & operator<<(std::ostream & o, mystruct const * rhs) { + if (rhs != NULL) + o << (*rhs).get_data()[0] << "," << (*rhs).get_data()[1]; + else + o << "NULL"; + return (o); +} + +// global variable for mem gestion of mystruct +std::vector< mystruct* > mem_list; + +// template print function +template + void print(ft::map mp, std::string name) { + + int i = 0; + typename ft::map::iterator it; + typename ft::map::iterator it_end = mp.end(); + + std::cout << "\n" << name << ":(map)\n"; + for (it = mp.begin(); it != it_end; ++it, i++) + std::cout << "[" << i << "]" << it->first << ":" << it->second << " "; + std::cout << "\nsize:" << mp.size() << "\n"; +} + +// template val() for instanciation of values for types : +// int, char, std::string, and mystruct* +template + T val(int n) { (void)n; return (T()); } +template <> + inline int val(int n) { return (n); } +template <> + inline char val(int n) { + + if (n <= 126 && n >= 33) + return n; + return (n % 94 + 33); +} +template <> + inline std::string val(int n) { + + std::string str; + std::stringstream stream; + + stream << n; + stream >> str; + stream.clear(); + return (str); +} +template <> + inline mystruct* val(int n) { + + mystruct *s = new mystruct(n); + mem_list.push_back(s); + return ( s ); +} +template + T val(std::string str) { (void)str; return (T()); } +template <> + inline int val(std::string str) { int i = str[0]; return (val(i)); } +template <> + inline char val(std::string str) { int i = str[0]; return (val(i)); } +template <> + inline std::string val(std::string str) { return (str); } +template <> + inline mystruct* val(std::string str) { int i = str[0]; return (val(i)); } + +// delete function for mem gestion of mystruct* +void delete_structs() { + + std::vector::iterator it; + std::vector::iterator it_end = mem_list.end(); + + for (it = mem_list.begin(); it != it_end; ++it) + delete *it; + mem_list.clear(); +} + +// all tests +TEST_M(tests_map_operator_assignation) +{ + // title + TITLE(cplusplus.com reference) + + ft::map first; + ft::map second; + + first[VALT('x')]=VALU(8); + first[VALT('y')]=VALU(16); + first[VALT('z')]=VALU(32); + + PRINT(first) + PRINT(second) + + second=first; // second now contains 3 ints + first=ft::map(); // and first is now empty + + std::cout << "Size of first: " << first.size() << '\n'; + std::cout << "Size of second: " << second.size() << '\n'; + + PRINT(first) + PRINT(second) + + DELETE +} + +TEST_M(tests_map_begin) +{ + // title + TITLE(cplusplus.com reference) + + ft::map mymap; + + mymap[VALT('b')] = VALU(100); + mymap[VALT('a')] = VALU(200); + mymap[VALT('c')] = VALU(300); + + PRINT(mymap) + + DELETE +} + +TEST_M(tests_map_end) +{ + // title + TITLE(cplusplus.com reference) + + ft::map mymap; + + mymap[VALT('b')] = VALU(100); + mymap[VALT('a')] = VALU(200); + mymap[VALT('c')] = VALU(300); + + PRINT(mymap) + + DELETE +} + +TEST_M(tests_map_rbegin) +{ + // title + TITLE(cplusplus.com reference) + + ft::map mymap; + + mymap[VALT('x')] = VALU(100); + mymap[VALT('y')] = VALU(200); + mymap[VALT('z')] = VALU(300); + + // show content: + typename ft::map::reverse_iterator rit; + for (rit=mymap.rbegin(); rit!=mymap.rend(); ++rit) + std::cout << rit->first << " => " << rit->second << '\n'; + + DELETE +} + +TEST_M(tests_map_rend) +{ + // title + TITLE(cplusplus.com reference) + + ft::map mymap; + + mymap[VALT('x')] = VALU(100); + mymap[VALT('y')] = VALU(200); + mymap[VALT('z')] = VALU(300); + + // show content: + typename ft::map::reverse_iterator rit; + for (rit=mymap.rbegin(); rit!=mymap.rend(); ++rit) + std::cout << rit->first << " => " << rit->second << '\n'; + + DELETE +} + +TEST_M(tests_map_empty) +{ + // title + TITLE(cplusplus.com reference) + + ft::map mymap; + + mymap[VALT('a')]=VALU(10); + mymap[VALT('b')]=VALU(20); + mymap[VALT('c')]=VALU(30); + + while (!mymap.empty()) + { + std::cout << mymap.begin()->first << " => " << mymap.begin()->second << '\n'; + mymap.erase(mymap.begin()); + } + + DELETE +} + +TEST_M(tests_map_size) +{ + // title + TITLE(cplusplus.com reference) + + ft::map mymap; + mymap[VALT('a')]=VALU(101); + mymap[VALT('b')]=VALU(202); + mymap[VALT('c')]=VALU(302); + + std::cout << "mymap.size() is " << mymap.size() << '\n'; + + PRINT(mymap) + + DELETE +} + +TEST_M(tests_map_max_size) +{ + // title + TITLE(cplusplus.com reference) + + int i; + std::map mymap; + + if (mymap.max_size()>1000) + { + for (i=0; i<1000; i++) mymap[i]=VALU(0); + std::cout << "The map contains 1000 elements.\n"; + } + else std::cout << "The map could not hold 1000 elements.\n"; + + DELETE +} + +TEST_M(tests_map_operator_access) +{ + // title + TITLE(cplusplus.com reference) + + ft::map mymap; + + mymap[VALT('a')]=VALU("An element"); + mymap[VALT('b')]=VALU("another element"); + mymap[VALT('c')]=mymap[VALT('b')]; + + std::cout << "mymap['a'] is " << mymap[VALT('a')] << '\n'; + std::cout << "mymap['b'] is " << mymap[VALT('b')] << '\n'; + std::cout << "mymap['c'] is " << mymap[VALT('c')] << '\n'; + std::cout << "mymap['d'] is " << mymap[VALT('d')] << '\n'; + + std::cout << "mymap now contains " << mymap.size() << " elements.\n"; + + DELETE +} + +TEST_M(tests_map_insert) +{ + // title + TITLE(cplusplus.com reference) + + ft::map mymap; + + // first insert function version (single parameter): + mymap.insert ( ft::pair(VALT('a'),VALU(100)) ); + mymap.insert ( ft::pair(VALT('z'),VALU(200)) ); + + ft::pair::iterator, bool> ret; + ret = mymap.insert ( ft::pair(VALT('z'),VALU(500)) ); + if (ret.second==false) { + std::cout << "element 'z' already existed"; + std::cout << " with a value of " << ret.first->second << '\n'; + } + + + // second insert function version (with hint position): + typename ft::map::iterator it = mymap.begin(); + mymap.insert (it, ft::pair(VALT('b'),VALU(300))); // max efficiency inserting + mymap.insert (it, ft::pair(VALT('c'),VALU(400))); // no max efficiency inserting + + // third insert function version (range insertion): + ft::map anothermap; + anothermap.insert(mymap.begin(),mymap.find('c')); + + PRINT(mymap) + PRINT(anothermap) + + DELETE +} + +TEST_M(tests_map_erase) +{ + // title + TITLE(cplusplus.com reference) + + ft::map mymap; + typename ft::map::iterator it; + + // insert some values: + mymap[VALT('a')]=VALU(10); + mymap[VALT('b')]=VALU(20); + mymap[VALT('c')]=VALU(30); + mymap[VALT('d')]=VALU(40); + mymap[VALT('e')]=VALU(50); + mymap[VALT('f')]=VALU(60); + + it=mymap.find(VALT('b')); + mymap.erase (it); // erasing by iterator + + mymap.erase (VALT('c')); // erasing by key + + it=mymap.find (VALT('e')); + mymap.erase ( it, mymap.end() ); // erasing by range + + PRINT(mymap) + + DELETE +} + +TEST_M(tests_map_swap) +{ + // title + TITLE(cplusplus.com reference) + + ft::map foo,bar; + + foo[VALT('x')]=VALU(100); + foo[VALT('y')]=VALU(200); + + bar[VALT('a')]=VALU(11); + bar[VALT('b')]=VALU(22); + bar[VALT('c')]=VALU(33); + + foo.swap(bar); + + PRINT(foo) + PRINT(bar) + + DELETE +} + +TEST_M(tests_map_clear) +{ + // title + TITLE(cplusplus.com reference) + + ft::map mymap; + + mymap[VALT('x')]=VALU(100); + mymap[VALT('y')]=VALU(200); + mymap[VALT('z')]=VALU(300); + + PRINT(mymap) + + mymap.clear(); + mymap[VALT('a')]=VALU(1101); + mymap[VALT('b')]=VALU(2202); + + PRINT(mymap) + + DELETE +} + +TEST_M(tests_map_key_comp) +{ + // title + TITLE(cplusplus.com reference) + + ft::map mymap; + + typename ft::map::key_compare mycomp = mymap.key_comp(); + + mymap[VALT('a')]=VALU(100); + mymap[VALT('b')]=VALU(200); + mymap[VALT('c')]=VALU(300); + + std::cout << "mymap contains:\n"; + + T highest = mymap.rbegin()->first; // key value of last element + + typename ft::map::iterator it = mymap.begin(); + do { + std::cout << it->first << " => " << it->second << '\n'; + } while ( mycomp((*it++).first, highest) ); + + std::cout << '\n'; + + DELETE +} + +TEST_M(tests_map_value_comp) +{ + // title + TITLE(cplusplus.com reference) + + ft::map mymap; + + mymap[VALT('x')]=VALU(1001); + mymap[VALT('y')]=VALU(2002); + mymap[VALT('z')]=VALU(3003); + + std::cout << "mymap contains:\n"; + + ft::pair highest = *mymap.rbegin(); // last element + + typename ft::map::iterator it = mymap.begin(); + do { + std::cout << it->first << " => " << it->second << '\n'; + } while ( mymap.value_comp()(*it++, highest) ); + + DELETE +} + +TEST_M(tests_map_find) +{ + // title + TITLE(cplusplus.com reference) + + ft::map mymap; + typename ft::map::iterator it; + + mymap[VALT('a')]=VALU(50); + mymap[VALT('b')]=VALU(100); + mymap[VALT('c')]=VALU(150); + mymap[VALT('d')]=VALU(200); + + it = mymap.find(VALT('b')); + if (it != mymap.end()) + mymap.erase (it); + + // print content: + std::cout << "elements in mymap:" << '\n'; + std::cout << "a => " << mymap.find(VALT('a'))->second << '\n'; + std::cout << "c => " << mymap.find(VALT('c'))->second << '\n'; + std::cout << "d => " << mymap.find(VALT('d'))->second << '\n'; + + DELETE +} + +TEST_M(tests_map_count) +{ + // title + TITLE(cplusplus.com reference) + + ft::map mymap; + T c; + + mymap [VALT('a')]=VALU(101); + mymap [VALT('c')]=VALU(202); + mymap [VALT('f')]=VALU(303); + + // to do this test with T as a 'string' or 'mystruct*' we should add overload + for (c=VALT('a'); c0) + std::cout << " is an element of mymap.\n"; + else + std::cout << " is not an element of mymap.\n"; + } + + DELETE +} + +TEST_M(tests_map_lower_bound) +{ + // title + TITLE(cplusplus.com reference) + + ft::map mymap; + typename ft::map::iterator itlow,itup; + + mymap[VALT('a')]=VALU(20); + mymap[VALT('b')]=VALU(40); + mymap[VALT('c')]=VALU(60); + mymap[VALT('d')]=VALU(80); + mymap[VALT('e')]=VALU(100); + + itlow=mymap.lower_bound (VALT('b')); // itlow points to b + itup=mymap.upper_bound (VALT('d')); // itup points to e (not d!) + + mymap.erase(itlow,itup); // erases [itlow,itup) + + PRINT(mymap) + + DELETE +} + +TEST_M(tests_map_upper_bound) +{ + // title + TITLE(cplusplus.com reference) + + ft::map mymap; + typename ft::map::iterator itlow,itup; + + mymap[VALT('a')]=VALU(20); + mymap[VALT('b')]=VALU(40); + mymap[VALT('c')]=VALU(60); + mymap[VALT('d')]=VALU(80); + mymap[VALT('e')]=VALU(100); + + itlow=mymap.lower_bound (VALT('b')); // itlow points to b + itup=mymap.upper_bound (VALT('d')); // itup points to e (not d!) + + mymap.erase(itlow,itup); // erases [itlow,itup) + + PRINT(mymap) + + DELETE +} + +TEST_M(tests_map_equal_range) +{ + // title + TITLE(cplusplus.com reference) + + ft::map mymap; + + mymap[VALT('a')]=VALU(10); + mymap[VALT('b')]=VALU(20); + mymap[VALT('c')]=VALU(30); + + ft::pair::iterator,typename ft::map::iterator> ret; + ret = mymap.equal_range(VALT('b')); + + std::cout << "lower bound points to: "; + std::cout << ret.first->first << " => " << ret.first->second << '\n'; + + std::cout << "upper bound points to: "; + std::cout << ret.second->first << " => " << ret.second->second << '\n'; + + DELETE +} + +TEST_M(tests_map_get_allocator) +{ + // title + TITLE(cplusplus.com reference) + + int psize; + ft::map mymap; + ft::pair* p; + + // allocate an array of 5 elements using mymap's allocator: + p=mymap.get_allocator().allocate(5); + + // assign some values to array + psize = sizeof(typename ft::map::value_type)*5; + + std::cout << "The allocated array has a size of " << psize << " bytes.\n"; + + mymap.get_allocator().deallocate(p,5); + + DELETE +} + +TEST_M(tests_map_relational_operators) +{ + // title + TITLE(cplusplus.com reference) + + ft::map alice; + ft::map bob; + ft::map eve; + (void)alice; + (void)bob; + (void)eve; + + alice[VALT(1)]=VALU('a'); + alice[VALT(2)]=VALU('b'); + alice[VALT(3)]=VALU('c'); + + bob[VALT(7)]=VALU('Z'); + bob[VALT(8)]=VALU('Y'); + bob[VALT(9)]=VALU('X'); + bob[VALT(10)]=VALU('W'); + + eve[VALT(1)]=VALU('a'); + eve[VALT(2)]=VALU('b'); + eve[VALT(3)]=VALU('c'); + + std::cout << std::boolalpha; + + // Compare non equal containers + std::cout << "alice == bob returns " << (alice == bob) << '\n'; + std::cout << "alice != bob returns " << (alice != bob) << '\n'; + std::cout << "alice < bob returns " << (alice < bob) << '\n'; + std::cout << "alice <= bob returns " << (alice <= bob) << '\n'; + std::cout << "alice > bob returns " << (alice > bob) << '\n'; + std::cout << "alice >= bob returns " << (alice >= bob) << '\n'; + + std::cout << '\n'; + + // Compare equal containers + std::cout << "alice == eve returns " << (alice == eve) << '\n'; + std::cout << "alice != eve returns " << (alice != eve) << '\n'; + std::cout << "alice < eve returns " << (alice < eve) << '\n'; + std::cout << "alice <= eve returns " << (alice <= eve) << '\n'; + std::cout << "alice > eve returns " << (alice > eve) << '\n'; + std::cout << "alice >= eve returns " << (alice >= eve) << '\n'; + + DELETE +} + + +TEST_M(tests_map_swap_non_member) +{ + // title + TITLE(cplusplus.com reference) + + ft::map alice; + ft::map bob; + + alice[VALT(1)]=VALU('a'); + alice[VALT(2)]=VALU('b'); + alice[VALT(3)]=VALU('c'); + + bob[VALT(7)]=VALU('Z'); + bob[VALT(8)]=VALU('Y'); + bob[VALT(9)]=VALU('X'); + bob[VALT(10)]=VALU('W'); + + // Print state before swap + PRINT(alice) + PRINT(bob) + + std::cout << "-- SWAP\n"; + std::swap(alice, bob); + + // Print state after swap + PRINT(alice) + PRINT(bob) + + DELETE +} + +template +void call_tests() { + + tests_map_operator_assignation(); + tests_map_begin(); + tests_map_end(); + tests_map_rbegin(); + tests_map_rend(); + tests_map_empty(); + tests_map_size(); + tests_map_max_size(); + tests_map_operator_access(); + tests_map_insert(); + tests_map_erase(); + tests_map_swap(); + tests_map_clear(); + tests_map_key_comp(); + tests_map_value_comp(); + tests_map_find(); + tests_map_count(); + tests_map_lower_bound(); + tests_map_upper_bound(); + tests_map_equal_range(); + tests_map_get_allocator(); + tests_map_relational_operators(); + tests_map_swap_non_member(); +} + +int main() { + + call_tests(); + call_tests(); + call_tests(); + call_tests(); + call_tests(); + call_tests(); + call_tests(); + call_tests(); + + return 0; +} + diff --git a/tests/main_map_2.cpp b/tests/main_map_2.cpp new file mode 100644 index 0000000..961fdef --- /dev/null +++ b/tests/main_map_2.cpp @@ -0,0 +1,862 @@ + + +#include +#include +#include // std::setw() +#include // std::reverse_iterator +#include // std::make_pair +#include // std::stringstream +#include + + +// toogle between test ft and stl +// ************************* +#include +#ifdef STL + namespace ft = std; +#else + #include "vector.hpp" + #include "map.hpp" + #include "reverse_iterator.hpp" +#endif + + +// colors +// ************************************************* +# define GRAY "\e[0;30m" +# define RED "\e[0;31m" +# define GREEN "\e[0;32m" +# define YELLOW "\e[0;33m" +# define BLUE "\e[0;34m" +# define PURPLE "\e[0;35m" +# define CYAN "\e[0;36m" +# define WHITE "\e[0;37m" + +# define B_GRAY "\e[1;30m" +# define B_RED "\e[1;31m" +# define B_GREEN "\e[1;32m" +# define B_YELLOW "\e[1;33m" +# define B_BLUE "\e[1;34m" +# define B_PURPLE "\e[1;35m" +# define B_CYAN "\e[1;36m" +# define B_WHITE "\e[1;37m" + +# define RESET "\e[0m" + + +// defines +// **************************************** +# define TITLE(s) std::cout << "\n" B_PURPLE #s RESET "\n\n"; +# define VAL(n) val(n) +# define VALT(n) val(n) +# define VALU(n) val(n) +# define TOI(n) toi(n) +# define PRINT(n) print<>(n, #n); +# define DELETE delete_structs(); + + +// adding each test to the list +// *************************** +#define TEST_V(f_name) \ + template struct s_ ## f_name : public A_test\ + { void func(); };\ + void f_name () {\ + add_to_list("", "", NULL);\ + add_to_list(#f_name, "int", new(s_ ## f_name ));\ + add_to_list(#f_name, "char", new(s_ ## f_name ));\ + add_to_list(#f_name, "std::string", new(s_ ## f_name ));\ + add_to_list(#f_name, "mystruct*", new(s_ ## f_name ));\ + }\ + template \ + void s_ ## f_name ::func() + +#define TEST_M(f_name) \ + template struct s_ ## f_name : public A_test\ + { void func(); };\ + void f_name () {\ + add_to_list("", "", NULL);\ + add_to_list(#f_name, "char, int", new(s_ ## f_name ));\ + add_to_list(#f_name, "char, char", new(s_ ## f_name ));\ + add_to_list(#f_name, "char, std::string", new(s_ ## f_name ));\ + add_to_list(#f_name, "char, mystruct*", new(s_ ## f_name ));\ + add_to_list(#f_name, "int, int", new(s_ ## f_name ));\ + add_to_list(#f_name, "int, char", new(s_ ## f_name ));\ + add_to_list(#f_name, "int, std::string", new(s_ ## f_name ));\ + add_to_list(#f_name, "int, mystruct*", new(s_ ## f_name ));\ + }\ + template \ + void s_ ## f_name ::func() + + +// structures +// ********************************************* +struct A_test +{ + virtual ~A_test(){}; + std::string title; + std::string type; + virtual void func() = 0; +}; + +struct mystruct { +public: + mystruct(int data = 0) + {_val = new int[2]; _val[0] = data; _val[1] = data;} + ~mystruct() + {delete[] _val;} + int * get_data() const + {return _val;} +private: + int * _val; +}; +std::ostream & operator<<(std::ostream & o, mystruct const * rhs) { + if (rhs != NULL) + o << (*rhs).get_data()[0] << "," << (*rhs).get_data()[1]; + else + o << "NULL"; + return (o); +} + + +// global variables +// *************************************** +std::vector< std::vector > test_list; +std::vector< mystruct* > mem_list; + + +// functions utiles +// *************************************** +void add_to_list(std::string title, std::string type, A_test* test) { + + std::vector test_sub_list; + std::vector< std::vector >::iterator it; + + // title != NULL for the first element + if (test == NULL) + { + test_list.push_back(test_sub_list); + return; + } + + test->title = title; + test->type = type; + it = test_list.end() - 1; + (*it).push_back(test); +} +void delete_structs() { + + std::vector::iterator it; + std::vector::iterator it_end = mem_list.end(); + + for (it = mem_list.begin(); it != it_end; ++it) + delete *it; + mem_list.clear(); +} + + +// templates print +// ***************************************** +template + void print(ft::vector vec, std::string name) { + + int i = 0; + typename ft::vector::iterator it; + typename ft::vector::iterator it_end = vec.end(); + + std::cout << "\n" << name << ":(vector)\n"; + for (it = vec.begin(); it != it_end; ++it, i++) + std::cout << "[" << i << "]" << *it << " "; + std::cout << "\nsize:" << vec.size() << " capacty:" << vec.capacity() << "\n"; +} +template + void print(ft::map mp, std::string name) { + + int i = 0; + typename ft::map::iterator it; + typename ft::map::iterator it_end = mp.end(); + + std::cout << "\n" << name << ":(map)\n"; + for (it = mp.begin(); it != it_end; ++it, i++) + std::cout << "[" << i << "]" << it->first << ":" << it->second << " "; + std::cout << "\nsize:" << mp.size() << "\n"; +} + +// templates get value +// ************************************* +// specialization in header, make it inline : +// https://stackoverflow.com/questions/63529059/c-specialized-method-templates-produce-multiple-definition-errors +template + T val(int n) { (void)n; return (T()); } +template <> + inline int val(int n) { return (n); } +template <> + inline char val(int n) { + + if (n <= 126 && n >= 33) + return n; + return (n % 94 + 33); +} +template <> + inline std::string val(int n) { + + std::string str; + std::stringstream stream; + + stream << n; + stream >> str; + stream.clear(); + return (str); +} +template <> + inline mystruct* val(int n) { + + mystruct *s = new mystruct(n); + mem_list.push_back(s); + return ( s ); +} +template + T val(std::string str) { (void)str; return (T()); } +template <> + inline int val(std::string str) { int i = str[0]; return (val(i)); } +template <> + inline char val(std::string str) { int i = str[0]; return (val(i)); } +template <> + inline std::string val(std::string str) { return (str); } +template <> + inline mystruct* val(std::string str) { int i = str[0]; return (val(i)); } + + +// templates to value +// ************************************** +template + int toi(T t) {(void)t; return (0); +} +template <> + inline int toi(int i) {return (i); +} +template <> + inline int toi(char c) {return (c); +} +template <> + inline int toi(std::string str) { + + int i; + std::stringstream stream; + + stream << str; + stream >> i; + stream.clear(); + return (i); +} +template <> + inline int toi(mystruct* s) { + + return ( s->get_data()[0] ); +} + + +// tests functions +// ***************************************** +TEST_M(tests_map_operator_assignation) +{ + // title + TITLE(cplusplus.com reference) + + ft::map first; + ft::map second; + + first[VALT('x')]=VALU(8); + first[VALT('y')]=VALU(16); + first[VALT('z')]=VALU(32); + + PRINT(first) + PRINT(second) + + second=first; // second now contains 3 ints + first=ft::map(); // and first is now empty + + std::cout << "Size of first: " << first.size() << '\n'; + std::cout << "Size of second: " << second.size() << '\n'; + + PRINT(first) + PRINT(second) + + DELETE +} + +TEST_M(tests_map_begin) +{ + // title + TITLE(cplusplus.com reference) + + ft::map mymap; + + mymap[VALT('b')] = VALU(100); + mymap[VALT('a')] = VALU(200); + mymap[VALT('c')] = VALU(300); + + PRINT(mymap) + + DELETE +} + +TEST_M(tests_map_end) +{ + // title + TITLE(cplusplus.com reference) + + ft::map mymap; + + mymap[VALT('b')] = VALU(100); + mymap[VALT('a')] = VALU(200); + mymap[VALT('c')] = VALU(300); + + PRINT(mymap) + + DELETE +} + +TEST_M(tests_map_rbegin) +{ + // title + TITLE(cplusplus.com reference) + + ft::map mymap; + + mymap[VALT('x')] = VALU(100); + mymap[VALT('y')] = VALU(200); + mymap[VALT('z')] = VALU(300); + + // show content: + typename ft::map::reverse_iterator rit; + for (rit=mymap.rbegin(); rit!=mymap.rend(); ++rit) + std::cout << rit->first << " => " << rit->second << '\n'; + + DELETE +} + +TEST_M(tests_map_rend) +{ + // title + TITLE(cplusplus.com reference) + + ft::map mymap; + + mymap[VALT('x')] = VALU(100); + mymap[VALT('y')] = VALU(200); + mymap[VALT('z')] = VALU(300); + + // show content: + typename ft::map::reverse_iterator rit; + for (rit=mymap.rbegin(); rit!=mymap.rend(); ++rit) + std::cout << rit->first << " => " << rit->second << '\n'; + + DELETE +} + +TEST_M(tests_map_empty) +{ + // title + TITLE(cplusplus.com reference) + + ft::map mymap; + + mymap[VALT('a')]=VALU(10); + mymap[VALT('b')]=VALU(20); + mymap[VALT('c')]=VALU(30); + + while (!mymap.empty()) + { + std::cout << mymap.begin()->first << " => " << mymap.begin()->second << '\n'; + mymap.erase(mymap.begin()); + } + + DELETE +} + +TEST_M(tests_map_size) +{ + // title + TITLE(cplusplus.com reference) + + ft::map mymap; + mymap[VALT('a')]=VALU(101); + mymap[VALT('b')]=VALU(202); + mymap[VALT('c')]=VALU(302); + + std::cout << "mymap.size() is " << mymap.size() << '\n'; + + PRINT(mymap) + + DELETE +} + +TEST_M(tests_map_max_size) +{ + // title + TITLE(cplusplus.com reference) + + int i; + std::map mymap; + + if (mymap.max_size()>1000) + { + for (i=0; i<1000; i++) mymap[i]=VALU(0); + std::cout << "The map contains 1000 elements.\n"; + } + else std::cout << "The map could not hold 1000 elements.\n"; + + DELETE +} + +TEST_M(tests_map_operator_access) +{ + // title + TITLE(cplusplus.com reference) + + ft::map mymap; + + mymap[VALT('a')]=VALU("An element"); + mymap[VALT('b')]=VALU("another element"); + mymap[VALT('c')]=mymap[VAL('b')]; + + std::cout << "mymap['a'] is " << mymap[VALT('a')] << '\n'; + std::cout << "mymap['b'] is " << mymap[VALT('b')] << '\n'; + std::cout << "mymap['c'] is " << mymap[VALT('c')] << '\n'; + std::cout << "mymap['d'] is " << mymap[VALT('d')] << '\n'; + + std::cout << "mymap now contains " << mymap.size() << " elements.\n"; + + DELETE +} + +TEST_M(tests_map_insert) +{ + // title + TITLE(cplusplus.com reference) + + ft::map mymap; + + // first insert function version (single parameter): + mymap.insert ( ft::pair(VALT('a'),VALU(100)) ); + mymap.insert ( ft::pair(VALT('z'),VALU(200)) ); + + ft::pair::iterator, bool> ret; + ret = mymap.insert ( ft::pair(VALT('z'),VALU(500)) ); + if (ret.second==false) { + std::cout << "element 'z' already existed"; + std::cout << " with a value of " << ret.first->second << '\n'; + } + + + // second insert function version (with hint position): + typename ft::map::iterator it = mymap.begin(); + mymap.insert (it, ft::pair(VALT('b'),VALU(300))); // max efficiency inserting + mymap.insert (it, ft::pair(VALT('c'),VALU(400))); // no max efficiency inserting + + // third insert function version (range insertion): + ft::map anothermap; + anothermap.insert(mymap.begin(),mymap.find('c')); + + PRINT(mymap) + PRINT(anothermap) + + DELETE +} + +TEST_M(tests_map_erase) +{ + // title + TITLE(cplusplus.com reference) + + ft::map mymap; + typename ft::map::iterator it; + + // insert some values: + mymap[VALT('a')]=VALU(10); + mymap[VALT('b')]=VALU(20); + mymap[VALT('c')]=VALU(30); + mymap[VALT('d')]=VALU(40); + mymap[VALT('e')]=VALU(50); + mymap[VALT('f')]=VALU(60); + + it=mymap.find(VALT('b')); + mymap.erase (it); // erasing by iterator + + mymap.erase (VALT('c')); // erasing by key + + it=mymap.find (VALT('e')); + mymap.erase ( it, mymap.end() ); // erasing by range + + PRINT(mymap) + + DELETE +} + +TEST_M(tests_map_swap) +{ + // title + TITLE(cplusplus.com reference) + + ft::map foo,bar; + + foo[VALT('x')]=VALU(100); + foo[VALT('y')]=VALU(200); + + bar[VALT('a')]=VALU(11); + bar[VALT('b')]=VALU(22); + bar[VALT('c')]=VALU(33); + + foo.swap(bar); + + PRINT(foo) + PRINT(bar) + + DELETE +} + +TEST_M(tests_map_clear) +{ + // title + TITLE(cplusplus.com reference) + + ft::map mymap; + + mymap[VALT('x')]=VALU(100); + mymap[VALT('y')]=VALU(200); + mymap[VALT('z')]=VALU(300); + + PRINT(mymap) + + mymap.clear(); + mymap[VALT('a')]=VALU(1101); + mymap[VALT('b')]=VALU(2202); + + PRINT(mymap) + + DELETE +} + +TEST_M(tests_map_key_comp) +{ + // title + TITLE(cplusplus.com reference) + + ft::map mymap; + + typename ft::map::key_compare mycomp = mymap.key_comp(); + + mymap[VALT('a')]=VALU(100); + mymap[VALT('b')]=VALU(200); + mymap[VALT('c')]=VALU(300); + + std::cout << "mymap contains:\n"; + + T highest = mymap.rbegin()->first; // key value of last element + + typename ft::map::iterator it = mymap.begin(); + do { + std::cout << it->first << " => " << it->second << '\n'; + } while ( mycomp((*it++).first, highest) ); + + std::cout << '\n'; + + DELETE +} + +TEST_M(tests_map_value_comp) +{ + // title + TITLE(cplusplus.com reference) + + ft::map mymap; + + mymap[VALT('x')]=VALU(1001); + mymap[VALT('y')]=VALU(2002); + mymap[VALT('z')]=VALU(3003); + + std::cout << "mymap contains:\n"; + + ft::pair highest = *mymap.rbegin(); // last element + + typename ft::map::iterator it = mymap.begin(); + do { + std::cout << it->first << " => " << it->second << '\n'; + } while ( mymap.value_comp()(*it++, highest) ); + + DELETE +} + +TEST_M(tests_map_find) +{ + // title + TITLE(cplusplus.com reference) + + ft::map mymap; + typename ft::map::iterator it; + + mymap[VALT('a')]=VALU(50); + mymap[VALT('b')]=VALU(100); + mymap[VALT('c')]=VALU(150); + mymap[VALT('d')]=VALU(200); + + it = mymap.find(VALT('b')); + if (it != mymap.end()) + mymap.erase (it); + + // print content: + std::cout << "elements in mymap:" << '\n'; + std::cout << "a => " << mymap.find(VALT('a'))->second << '\n'; + std::cout << "c => " << mymap.find(VALT('c'))->second << '\n'; + std::cout << "d => " << mymap.find(VALT('d'))->second << '\n'; + + DELETE +} + +TEST_M(tests_map_count) +{ + // title + TITLE(cplusplus.com reference) + + ft::map mymap; + T c; + + mymap [VALT('a')]=VALU(101); + mymap [VALT('c')]=VALU(202); + mymap [VALT('f')]=VALU(303); + + // to do this test with T as a 'string' or 'mystruct*' we should add overload + for (c=VALT('a'); c0) + std::cout << " is an element of mymap.\n"; + else + std::cout << " is not an element of mymap.\n"; + } + + DELETE +} + +TEST_M(tests_map_lower_bound) +{ + // title + TITLE(cplusplus.com reference) + + ft::map mymap; + typename ft::map::iterator itlow,itup; + + mymap[VALT('a')]=VALU(20); + mymap[VALT('b')]=VALU(40); + mymap[VALT('c')]=VALU(60); + mymap[VALT('d')]=VALU(80); + mymap[VALT('e')]=VALU(100); + + itlow=mymap.lower_bound (VALT('b')); // itlow points to b + itup=mymap.upper_bound (VALT('d')); // itup points to e (not d!) + + mymap.erase(itlow,itup); // erases [itlow,itup) + + PRINT(mymap) + + DELETE +} + +TEST_M(tests_map_upper_bound) +{ + // title + TITLE(cplusplus.com reference) + + ft::map mymap; + typename ft::map::iterator itlow,itup; + + mymap[VALT('a')]=VALU(20); + mymap[VALT('b')]=VALU(40); + mymap[VALT('c')]=VALU(60); + mymap[VALT('d')]=VALU(80); + mymap[VALT('e')]=VALU(100); + + itlow=mymap.lower_bound (VALT('b')); // itlow points to b + itup=mymap.upper_bound (VALT('d')); // itup points to e (not d!) + + mymap.erase(itlow,itup); // erases [itlow,itup) + + PRINT(mymap) + + DELETE +} + +TEST_M(tests_map_equal_range) +{ + // title + TITLE(cplusplus.com reference) + + ft::map mymap; + + mymap[VALT('a')]=VALU(10); + mymap[VALT('b')]=VALU(20); + mymap[VALT('c')]=VALU(30); + + ft::pair::iterator,typename ft::map::iterator> ret; + ret = mymap.equal_range(VALT('b')); + + std::cout << "lower bound points to: "; + std::cout << ret.first->first << " => " << ret.first->second << '\n'; + + std::cout << "upper bound points to: "; + std::cout << ret.second->first << " => " << ret.second->second << '\n'; + + DELETE +} + +TEST_M(tests_map_get_allocator) +{ + // title + TITLE(cplusplus.com reference) + + int psize; + ft::map mymap; + ft::pair* p; + + // allocate an array of 5 elements using mymap's allocator: + p=mymap.get_allocator().allocate(5); + + // assign some values to array + psize = sizeof(typename ft::map::value_type)*5; + + std::cout << "The allocated array has a size of " << psize << " bytes.\n"; + + mymap.get_allocator().deallocate(p,5); + + DELETE +} + +TEST_M(tests_map_relational_operators) +{ + // title + TITLE(cplusplus.com reference) + + ft::map alice; + ft::map bob; + ft::map eve; + (void)alice; + (void)bob; + (void)eve; + + alice[VALT(1)]=VALU('a'); + alice[VALT(2)]=VALU('b'); + alice[VALT(3)]=VALU('c'); + + bob[VALT(7)]=VALU('Z'); + bob[VALT(8)]=VALU('Y'); + bob[VALT(9)]=VALU('X'); + bob[VALT(10)]=VALU('W'); + + eve[VALT(1)]=VALU('a'); + eve[VALT(2)]=VALU('b'); + eve[VALT(3)]=VALU('c'); + + std::cout << std::boolalpha; + + // Compare non equal containers + std::cout << "alice == bob returns " << (alice == bob) << '\n'; + std::cout << "alice != bob returns " << (alice != bob) << '\n'; + std::cout << "alice < bob returns " << (alice < bob) << '\n'; + std::cout << "alice <= bob returns " << (alice <= bob) << '\n'; + std::cout << "alice > bob returns " << (alice > bob) << '\n'; + std::cout << "alice >= bob returns " << (alice >= bob) << '\n'; + + std::cout << '\n'; + + // Compare equal containers + std::cout << "alice == eve returns " << (alice == eve) << '\n'; + std::cout << "alice != eve returns " << (alice != eve) << '\n'; + std::cout << "alice < eve returns " << (alice < eve) << '\n'; + std::cout << "alice <= eve returns " << (alice <= eve) << '\n'; + std::cout << "alice > eve returns " << (alice > eve) << '\n'; + std::cout << "alice >= eve returns " << (alice >= eve) << '\n'; + + DELETE +} + + +TEST_M(tests_map_swap_non_member) +{ + // title + TITLE(cplusplus.com reference) + + ft::map alice; + ft::map bob; + + alice[VALT(1)]=VALU('a'); + alice[VALT(2)]=VALU('b'); + alice[VALT(3)]=VALU('c'); + + bob[VALT(7)]=VALU('Z'); + bob[VALT(8)]=VALU('Y'); + bob[VALT(9)]=VALU('X'); + bob[VALT(10)]=VALU('W'); + + // Print state before swap + PRINT(alice) + PRINT(bob) + + std::cout << "-- SWAP\n"; + std::swap(alice, bob); + + // Print state after swap + PRINT(alice) + PRINT(bob) + + DELETE +} + + +int main() { + + tests_map_operator_assignation(); + tests_map_begin(); + tests_map_end(); + tests_map_rbegin(); + tests_map_rend(); + tests_map_empty(); + tests_map_size(); + tests_map_max_size(); + tests_map_operator_access(); + tests_map_insert(); + tests_map_erase(); + tests_map_swap(); + tests_map_clear(); + tests_map_key_comp(); + tests_map_value_comp(); + tests_map_find(); + tests_map_count(); + tests_map_lower_bound(); + tests_map_upper_bound(); + tests_map_equal_range(); + tests_map_get_allocator(); + tests_map_relational_operators(); + tests_map_swap_non_member(); + + + // execute tests and print them : + int size = test_list.size(); + int sub_size; + for(int i = 0; i < size; i++) + { + std::cout << "\n" B_YELLOW "[" << i + 1 << "/" << size << "] " + << test_list[i][0]->title << RESET << "\n"; + sub_size = test_list[i].size(); + for (int j = 0; j < sub_size; j++) + { + std::cout << "\n" << B_CYAN << "-- " << test_list[i][j]->type + << " --" << RESET "\n"; + test_list[i][j]->func(); + delete test_list[i][j]; + } + } + std::cout << "\n"; + + return 0; +} + diff --git a/tests/main_stack_1.cpp b/tests/main_stack_1.cpp new file mode 100644 index 0000000..e3c7480 --- /dev/null +++ b/tests/main_stack_1.cpp @@ -0,0 +1,187 @@ + +#include +#include +#include // std::setw() +#include // std::reverse_iterator +#include // std::make_pair +#include // std::stringstream +#include +#include +#include + +// toogle ft in stl +#ifdef STL + namespace ft = std; +#else + #include "vector.hpp" + #include "map.hpp" + #include "stack.hpp" + #include "reverse_iterator.hpp" +#endif + +// defines +# define TEST(s) template void s () +# define TITLE(s) std::cout << "\n" B_PURPLE #s RESET "\n\n"; +# define VAL(n) val(n) +# define TOI(n) toi(n) +# define PRINT(n) print<>(n, #n); +# define DELETE delete_structs(); + +// colors +# define GRAY "\e[0;30m" +# define RED "\e[0;31m" +# define GREEN "\e[0;32m" +# define YELLOW "\e[0;33m" +# define BLUE "\e[0;34m" +# define PURPLE "\e[0;35m" +# define CYAN "\e[0;36m" +# define WHITE "\e[0;37m" + +# define B_GRAY "\e[1;30m" +# define B_RED "\e[1;31m" +# define B_GREEN "\e[1;32m" +# define B_YELLOW "\e[1;33m" +# define B_BLUE "\e[1;34m" +# define B_PURPLE "\e[1;35m" +# define B_CYAN "\e[1;36m" +# define B_WHITE "\e[1;37m" + +# define RESET "\e[0m" + +// mystruct declaration +struct mystruct { +public: + mystruct(int data = 0); + ~mystruct(); + int * get_data() const; +private: + int * _val; +}; +std::ostream & operator<<(std::ostream & o, mystruct const * rhs); + +// mystruct definition +mystruct::mystruct(int data) + {_val = new int[2]; _val[0] = data; _val[1] = data;} +mystruct::~mystruct() + {delete[] _val;} +int * mystruct::get_data() const + {return _val;} +std::ostream & operator<<(std::ostream & o, mystruct const * rhs) { + if (rhs != NULL) + o << (*rhs).get_data()[0] << "," << (*rhs).get_data()[1]; + else + o << "NULL"; + return (o); +} + +// global variable for mem gestion of mystruct +std::vector< mystruct* > mem_list; + +// template print function +template + void print(ft::stack& st, std::string name) { + + std::cout << "\n" << name << ":(map)\n"; + for (int i = st.size(); i > 0 ; i--, st.pop()) + std::cout << "[" << i << "]" << st.top() << " "; + std::cout << "\nsize:" << st.size() << "\n"; +} + +// template val() for instanciation of values for types : +// int, char, std::string, and mystruct* +template + T val(int n) { (void)n; return (T()); } +template <> + inline int val(int n) { return (n); } +template <> + inline char val(int n) { + + if (n <= 126 && n >= 33) + return n; + return (n % 94 + 33); +} +template <> + inline std::string val(int n) { + + std::string str; + std::stringstream stream; + + stream << n; + stream >> str; + stream.clear(); + return (str); +} +template <> + inline mystruct* val(int n) { + + mystruct *s = new mystruct(n); + mem_list.push_back(s); + return ( s ); +} +template + T val(std::string str) { (void)str; return (T()); } +template <> + inline int val(std::string str) { int i = str[0]; return (val(i)); } +template <> + inline char val(std::string str) { int i = str[0]; return (val(i)); } +template <> + inline std::string val(std::string str) { return (str); } +template <> + inline mystruct* val(std::string str) { int i = str[0]; return (val(i)); } + +// delete function for mem gestion of mystruct* +void delete_structs() { + + std::vector::iterator it; + std::vector::iterator it_end = mem_list.end(); + + for (it = mem_list.begin(); it != it_end; ++it) + delete *it; + mem_list.clear(); +} + +// all tests +TEST(tests_stack_constructor) +{ + // title + TITLE(simple test) + + std::deque mydeque (3,VAL(100)); // deque with 3 elements + std::vector myvector (2,VAL(200)); // vector with 2 elements + + ft::stack first; // empty stack + ft::stack second (mydeque); // stack initialized to copy of deque + +// ft::stack< T,std::vector > third; // empty stack using vector +// ft::stack< T,std::vector > fourth (myvector); +// +// std::cout << "size of first: " << first.size() << '\n'; +// std::cout << "size of second: " << second.size() << '\n'; +// std::cout << "size of third: " << third.size() << '\n'; +// std::cout << "size of fourth: " << fourth.size() << '\n'; +// +// PRINT(first) +// PRINT(second) +// PRINT(third) +// PRINT(fourth) +// +// DELETE +} + +template +void call_tests() { + + tests_stack_constructor(); +} + +int main() { + + call_tests(); +// call_tests(); +// call_tests(); +// call_tests(); + + return 0; +} + + diff --git a/tests/test.sh b/tests/test.sh index dbdca9a..219ffb9 100644 --- a/tests/test.sh +++ b/tests/test.sh @@ -5,13 +5,13 @@ TEST_DIR=$(dirname $0) OUTPUT_STL="output_stl.log" OUTPUT_FT="output_ft.log" -make stl > /dev/null -echo -e "\nstl :" -time ./containers > tests/$OUTPUT_STL +make > /dev/null + +echo -e "\nstl :" +time ./containers_ft > tests/$OUTPUT_STL -make ft > /dev/null echo -e "\nft :" -time ./containers > tests/$OUTPUT_FT +time ./containers_stl > tests/$OUTPUT_FT diff --context=0 --color=always tests/$OUTPUT_STL tests/$OUTPUT_FT diff --git a/tests/tests_map.cpp b/tests/tests_map.cpp index 54373fc..a6cc264 100644 --- a/tests/tests_map.cpp +++ b/tests/tests_map.cpp @@ -1,7 +1,4 @@ -#ifndef TESTS_MAP_CPP -#define TESTS_MAP_CPP - #include "tests_utils.hpp" /**/ // UTILS for some tests @@ -336,7 +333,6 @@ TEST_M(tests_map_clear) DELETE } -/* TEST_M(tests_map_key_comp) { // title @@ -386,7 +382,6 @@ TEST_M(tests_map_value_comp) DELETE } -*/ TEST_M(tests_map_find) { @@ -439,7 +434,6 @@ TEST_M(tests_map_count) DELETE } -/* TEST_M(tests_map_lower_bound) { // title @@ -532,7 +526,6 @@ TEST_M(tests_map_get_allocator) DELETE } -*/ TEST_M(tests_map_relational_operators) { @@ -614,5 +607,3 @@ TEST_M(tests_map_swap_non_member) DELETE } -#endif - diff --git a/tests/tests_stack.cpp b/tests/tests_stack.cpp new file mode 100644 index 0000000..ea3099d --- /dev/null +++ b/tests/tests_stack.cpp @@ -0,0 +1,29 @@ + +#include "tests_utils.hpp" + +TEST(tests_stack_constructor) +{ + // title + TITLE(simple test) + + std::deque mydeque (3,VAL(100)); // deque with 3 elements + std::vector myvector (2,VAL(200)); // vector with 2 elements + + ft::stack first; // empty stack + ft::stack second (mydeque); // stack initialized to copy of deque + +// ft::stack< T,std::vector > third; // empty stack using vector +// ft::stack< T,std::vector > fourth (myvector); +// +// std::cout << "size of first: " << first.size() << '\n'; +// std::cout << "size of second: " << second.size() << '\n'; +// std::cout << "size of third: " << third.size() << '\n'; +// std::cout << "size of fourth: " << fourth.size() << '\n'; +// +// PRINT(first) +// PRINT(second) +// PRINT(third) +// PRINT(fourth) +// +// DELETE +} diff --git a/tests/tests_vector.cpp b/tests/tests_vector.cpp index 87fd466..da3afb8 100644 --- a/tests/tests_vector.cpp +++ b/tests/tests_vector.cpp @@ -1,7 +1,4 @@ -#ifndef TESTS_VECTOR_CPP -#define TESTS_VECTOR_CPP - #include "tests_utils.hpp" TEST_V(tests_vector_constructor) @@ -870,4 +867,3 @@ TEST_V(tests_vector_reverse_iterators) DELETE } -#endif