#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 // 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; ~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) { 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::val.

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.