daily pastebin goal
56%
SHARE
TWEET

Untitled

a guest Dec 16th, 2018 69 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include<memory>
  2.  
  3. template <typename T>
  4. class List {
  5. public:
  6.     class ListNode {
  7.     public:
  8.  
  9.         ListNode() {
  10.             next = nullptr;
  11.             prev = nullptr;
  12.         }
  13.  
  14.         ListNode(const ListNode& rhs) {
  15.             next = rhs.next;
  16.             prev = rhs.prev;
  17.             value = rhs.value;
  18.         }
  19.  
  20.         ListNode(ListNode&& rhs) {
  21.             next = rhs.next;
  22.             prev = rhs.prev;
  23.             rhs.next = nullptr;
  24.             rhs.prev = nullptr;
  25.             value = rhs.value;
  26.         }
  27.  
  28.         ListNode* prev;
  29.         ListNode* next;
  30.         T* value;
  31.     };
  32.  
  33.     class Iterator {
  34.     public:
  35.  
  36.         Iterator() {
  37.             node = std::make_shared<ListNode>(new ListNode());
  38.         }
  39.  
  40.         Iterator& operator++() {
  41.             node = node->next;
  42.         }
  43.         Iterator operator++(int) {
  44.             node = node -> next;
  45.         }
  46.  
  47.         Iterator& operator--() {
  48.             node = node -> prev;
  49.         }
  50.         Iterator operator--(int) {
  51.             node = node -> prev;
  52.         }
  53.  
  54.         T& operator*() const { ///////////////////////////////////////////////////////
  55.             return *(this->node->value);
  56.         }
  57.         T* operator->() const {
  58.             return this->node->value;
  59.         }
  60.  
  61.         bool operator==(const Iterator& rhs) const {
  62.             return (node == rhs.node);
  63.         }
  64.         bool operator!=(const Iterator& rhs) const {
  65.             return  (node != rhs.node);
  66.         }
  67.  
  68.         std::shared_ptr<ListNode> node;
  69.     };
  70.  
  71.     void Unlink(ListNode* node) {
  72.         if(node->prev)
  73.             node->prev->next = node->next;
  74.         if(node->next)
  75.             node->next->prev = node->prev;
  76.     }
  77.  
  78.     void LinkAfter(ListNode* target, ListNode* after) {
  79.         if(target->next)
  80.             target->next->prev = after;
  81.         target->next = after;
  82.         after->next = target->next;
  83.         after->prev = target;
  84.     }
  85.  
  86.     void init() {
  87.         begin = std::make_shared<Iterator>(new Iterator());
  88.         end = std::make_shared<Iterator>(new Iterator());
  89.         size = 0;
  90.     }
  91.  
  92.     List() {
  93.         init();
  94.     }
  95.  
  96.     List(const List& list) {
  97.         init();
  98.         Iterator beg = list.Begin();
  99.         Iterator finish = list.End();
  100.         while(beg != finish) {
  101.             LinkAfter(end.get()->node.get(), beg->node);
  102.             size++;
  103.             beg++;
  104.         }
  105.     }
  106.  
  107.     List(List&& list) noexcept {
  108.         init();
  109.         Iterator beg = list.Begin();
  110.         Iterator finish = list.End();
  111.         begin = beg.node;
  112.         beg.node.reset();
  113.         end = finish.node;
  114.         finish.node.reset();
  115.         size = list.Size();
  116.         list.size = 0;
  117.     }
  118.     ~List();
  119.  
  120.     List& operator=(const List& list);
  121.     List& operator=(List&& list);
  122.  
  123.     bool IsEmpty() const {
  124.         return size == 0;
  125.     }
  126.  
  127.     size_t Size() const {
  128.         return size;
  129.     }
  130.  
  131.     void PushBack(const T& elem);
  132.     void PushBack(T&& elem);
  133.     void PushFront(const T& elem);
  134.     void PushFront(T&& elem);
  135.  
  136.     T& Front();
  137.     const T& Front() const;
  138.     T& Back();
  139.     const T& Back() const;
  140.  
  141.     void PopBack();
  142.     void PopFront();
  143.  
  144.     Iterator Begin() const{
  145.         return *(begin.get());
  146.     }
  147.     Iterator End() const{
  148.         return *(end.get());
  149.     }
  150.     size_t size;
  151. private:
  152.     std::shared_ptr<Iterator> begin;
  153.     std::shared_ptr<Iterator> end;
  154. };
  155.  
  156. template <typename T>
  157. typename List<T>::Iterator begin(List<T>& list);
  158.  
  159. template <typename T>
  160. typename List<T>::Iterator end(List<T>& list);
  161.  
  162. int main() {
  163.     List<int> a;
  164.     return 0;
  165. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top