From 28acc5ef51c3fd83dc7159df26b724237dfcd81b Mon Sep 17 00:00:00 2001 From: hugogogo Date: Tue, 21 Jun 2022 01:50:41 +0200 Subject: [PATCH] map filled luky style --- headers/map.hpp | 199 +++++++++++++++--------------- templates/map.tpp | 288 ++++++++++++++++++++++++++++++-------------- tests/tests_map.cpp | 3 +- 3 files changed, 301 insertions(+), 189 deletions(-) diff --git a/headers/map.hpp b/headers/map.hpp index c00ade3..e4c51fa 100644 --- a/headers/map.hpp +++ b/headers/map.hpp @@ -36,137 +36,138 @@ public: typedef Bst bst_map; -// typedef typename bst_map::iterator iterator; -// typedef typename bst_map::const_iterator const_iterator; -// typedef typename bst_map::reverse_iterator reverse_iterator; -// typedef typename bst_map::const_reverse_iterator const_reverse_iterator; + typedef typename bst_map::iterator iterator; + typedef typename bst_map::const_iterator const_iterator; + typedef typename bst_map::reverse_iterator reverse_iterator; + typedef typename bst_map::const_reverse_iterator const_reverse_iterator; /**************** * member class : ****************/ -// // https://en.cppreference.com/w/cpp/container/map/value_compare -// class value_compare : public std::binary_function -// { -// friend class map; -// protected: -// Compare comp; -// value_compare(Compare c) : comp(c) {} -// public: -// bool operator() (const value_type& x, const value_type& y) const -// { return comp(x.first, y.first); } -// }; + // 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; + protected: + Compare comp; + value_compare(Compare c) : comp(c) {} + public: + bool operator() (const value_type& x, const value_type& y) const + { return comp(x.first, y.first); } + }; /************ * copliens : ************/ -//// constructors ------------------------------ +// 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); + 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); /************* * 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; +// 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 : ************/ -//// empty ------------------------------------- -// bool empty() const; -//// size -------------------------------------- -// size_type size() const; -//// max_size ---------------------------------- -// size_type max_size() const; +// empty ------------------------------------- + bool empty() const; +// size -------------------------------------- + size_type size() const; +// max_size ---------------------------------- + size_type max_size() const; /****************** * element access : ******************/ -//// operator[] -------------------------------- +// operator[] -------------------------------- mapped_type & operator[] (const key_type& k); /************* * 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(); +// 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(); /************* * observers : *************/ -//// key_comp ---------------------------------- -// key_compare key_comp() const; -//// value_comp -------------------------------- -// value_compare value_comp() const; +// 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); +// 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; +// get_allocator ----------------------------- + allocator_type get_allocator() const; private: + bst_map _bst; allocator_type _allocator; key_compare _comp; - bst_map _bst; }; @@ -174,27 +175,27 @@ private: /************************ * 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 ); +// 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 diff --git a/templates/map.tpp b/templates/map.tpp index e0df93d..506a818 100644 --- a/templates/map.tpp +++ b/templates/map.tpp @@ -10,141 +10,253 @@ namespace ft { /************ * copliens : ************/ -//// constructors ------------------------------ +// constructors ------------------------------ MP_TPL MP:: map (const key_compare & comp, const allocator_type & alloc) - : _allocator(alloc) + : _bst() + , _allocator(alloc) , _comp(comp) { return; } -// 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); +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 ------------------------------------- -// 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; +// 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 ------------------------------------- -// bool empty() const; -//// size -------------------------------------- -// size_type size() const; -//// max_size ---------------------------------- -// size_type max_size() const; +// 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[] -------------------------------- +// operator[] -------------------------------- MP_TPL typename MP::mapped_type& MP:: - operator[] (const key_type& k) { - - return _bst[k]; -} + operator[] (const key_type& k) { return _bst[k]; } /************* * 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(); +// 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 ---------------------------------- -// key_compare key_comp() const; -//// value_comp -------------------------------- -// value_compare value_comp() const; +// 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 -------------------------------------- -// 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); +// 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 ----------------------------- -// allocator_type get_allocator() const; +// get_allocator ----------------------------- +MP_TPL typename MP::allocator_type MP:: + get_allocator() const { return (_allocator); } /************************ * 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 ); +// 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._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._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); } +// swap (map) ----------------------------- +template< class Key, class T, class Compare, class Alloc > void swap + ( const MP& lhs, const MP& rhs ) { lhs.swap(rhs); } } // namespace ft diff --git a/tests/tests_map.cpp b/tests/tests_map.cpp index b5129f1..ecb4a1d 100644 --- a/tests/tests_map.cpp +++ b/tests/tests_map.cpp @@ -14,8 +14,7 @@ TEST_M(tests_map_simple) mp[VALT('a')] = VALU(10); -// it = mp.begin(); -// PRINT(mp) + PRINT(mp) DELETE }