![// end is inclusive end of range to remove
static void
unhook (Node* begin, Node* end)
{
begin -> prev -> next = end -> next;
end -> next -> prev = begin -> prev;
}
// insert [first,last] before this
void
hook (Node* first, Node* last)
{
first -> prev = prev;
last -> next = this;
prev -> next = first;
prev = last;
}
// insert first before this
void
hook (Node* first)
{
hook (first, first);
}
void
unhook ()
{
Node::unhook (this, this);
}
T data;
Node* next{nullptr};
Node* prev{nullptr};
};
struct Iterator
{
using value_type = List::value_type;
using pointer = List::pointer;
using reference = List::reference;
using difference_type = List::difference_type;
using iterator_category = std::bidirectional_iterator_tag;
public:
Iterator () noexcept = default;
Iterator (Iterator const&) noexcept = default;
Iterator (Iterator&&) noexcept = default;](https://image.slidesharecdn.com/includeltfunctionalgtincludeltiteratorgtinclu-230318083244-28e02e37/85/include-ltfunctionalgt-include-ltiteratorgt-inclu-pdf-2-320.jpg)
include ltfunctionalgt include ltiteratorgt inclu.pdf
- 1. #include <functional> #include <iterator> #include <limits> #include <memory> template<typename T> class List { private: struct Node; struct Iterator; struct ConstIterator; public: using value_type = T; using size_type = std::size_t; using difference_type = std::ptrdiff_t; using reference = value_type&; using const_reference = value_type const&; using pointer = value_type*; using const_pointer = value_type const*; using iterator = Iterator; using const_iterator = ConstIterator; using reverse_iterator = std::reverse_iterator<iterator>; using const_reverse_iterator = std::reverse_iterator<const_iterator>; private: struct Node { Node () : data () { } Node (T const& v) : data (v) { } Node (T const& v, Node* n, Node* p) : data (v), next (n), prev (p) { } Node (T&& v) : data (std::move (v)) { } Node (T&& v, Node* n, Node* p) : data (std::move (v)), next (n), prev (p) { } // this is start of range to remove
- 2. // end is inclusive end of range to remove static void unhook (Node* begin, Node* end) { begin -> prev -> next = end -> next; end -> next -> prev = begin -> prev; } // insert [first,last] before this void hook (Node* first, Node* last) { first -> prev = prev; last -> next = this; prev -> next = first; prev = last; } // insert first before this void hook (Node* first) { hook (first, first); } void unhook () { Node::unhook (this, this); } T data; Node* next{nullptr}; Node* prev{nullptr}; }; struct Iterator { using value_type = List::value_type; using pointer = List::pointer; using reference = List::reference; using difference_type = List::difference_type; using iterator_category = std::bidirectional_iterator_tag; public: Iterator () noexcept = default; Iterator (Iterator const&) noexcept = default; Iterator (Iterator&&) noexcept = default;
- 3. ~Iterator () = default; Iterator& operator= (Iterator const&) noexcept = default; Iterator& operator= (Iterator&&) noexcept = default; Iterator (Node const* n) : m_nodePtr (const_cast<Node*> (n)) { } reference operator* () const { return m_nodePtr->data; } pointer operator-> () const { return &(m_nodePtr->data); } // advances to the "next" pointer, returns reference to self Iterator& operator++ () { m_nodePtr = m_nodePtr -> next; return *this; } // advances to the "next" pointer, returns copy of self prior to advancement Iterator operator++ (int) { iterator temp(*this); ++(*this); return temp; } // advances to the "prev" pointer, returns reference to self Iterator& operator-- () { m_nodePtr = m_nodePtr -> prev; return *this; } // advances to the "prev" pointer, returns copy of self prior to advancement Iterator operator-- (int) {
- 4. iterator temp(*this); --(*this); return temp; } // compares the underlying pointers for equality friend bool operator== (Iterator const& i, Iterator const& j) { return i.m_nodePtr == j.m_nodePtr; } friend bool operator!= (Iterator const& i, Iterator const& j) { return !(i == j); } private: Node* m_nodePtr{nullptr}; friend class List; }; struct ConstIterator { using value_type = List::value_type; using pointer = List::const_pointer; using reference = List::const_reference; using difference_type = List::difference_type; using iterator_category = std::bidirectional_iterator_tag; public: ConstIterator () noexcept = default; ConstIterator (ConstIterator const&) noexcept = default; ConstIterator (ConstIterator&&) noexcept = default; ~ConstIterator () = default; ConstIterator& operator= (ConstIterator const&) noexcept = default; ConstIterator& operator= (ConstIterator&&) noexcept = default; ConstIterator (Node const* n) : m_nodePtr (const_cast<Node*> (n)) { } ConstIterator (Iterator const& i) : m_nodePtr (i.m_nodePtr) { } reference operator* () const
- 5. { return m_nodePtr->data; } pointer operator-> () const { return &(m_nodePtr->data); } ConstIterator& operator++ () { m_nodePtr = m_nodePtr -> next; return *this; } ConstIterator operator++ (int) { iterator temp(*this); ++(*this); return temp; } ConstIterator& operator-- () { m_nodePtr = m_nodePtr -> prev; return *this; } ConstIterator operator-- (int) { iterator temp(*this); --(*this); return temp; } friend bool operator== (ConstIterator const& i, ConstIterator const& j) { return i.m_nodePtr == j.m_nodePtr; } friend bool operator!= (ConstIterator const& i, ConstIterator const& j) { return !(i == j);
- 6. } private: Node* m_nodePtr{nullptr}; friend class List; }; // transfers [first, last) to before pos and sets all links static void transfer (const_iterator pos, const_iterator first, const_iterator last) { if (first == last) { return; } first.m_nodePtr->prev->next = last.m_nodePtr->next; last.m_nodePtr->next->prev = first.m_nodePtr->prev; pos.m_nodePtr->hook(first.m_nodePtr, last.m_nodePtr); } public: // default constructor List () /* remember to include the member initializer list */ { // TODO // make m_header a circular node } // size-value constructor explicit List (size_type count, T const& value) : List () { // TODO } explicit List (size_type count) : List () { while (count--) { emplace_back (); } } // range constructor template<typename InputIt, Requires (concepts::ForwardIterator, InputIt)> List (InputIt first, InputIt last) : List () { // TODO
- 7. } // copy constructor List (List const& other) : List (other.begin (), other.end ()) { } // move constructor List (List&& other) : m_header (std::exchange (other.m_header, Node ())) , m_size (std::exchange (other.m_size, 0)) { } // intializer_list constructor List (std::initializer_list<T> init) : List (init.begin (), init.end ()) { } // destructor ~List () { // TODO // Remember to delete all allocated nodes! } // copy assignment List& operator= (List const& other) { // TODO // Remember to check for self-assignment // Hint: look at versions of assign() below... } // move assignment List& operator= (List&& other) noexcept { if (&other != this) { clear (); m_header.next = std::exchange (other.m_header.next, &(other.m_header)); m_header.prev = std::exchange (other.m_header.prev, &(other.m_header)); m_size = std::exchange (other.m_size, 0); } return *this;
- 8. } // initializer_list assignment List& operator= (std::initializer_list<T> ilist) { assign (ilist); return *this; } void assign (size_type count, T const& value) { List l (count, value); swap (l); } template<typename InputIt, Requires (concepts::ForwardIterator, InputIt)> void assign (InputIt first, InputIt last) { List l (first, last); swap (l); } void assign (std::initializer_list<T> ilist) { // TODO } ... private: Node m_header; size_type m_size; }; ... Please complete the implementation marked TODO for the above member functions.