/* Created by Yevgeny Antonov yevgeny1978@mail.ru List container in C++ Date: 05/24/2019 */ #include #include #include template class List { private: struct Node { T value; Node* next; Node* previous; }; Node* first_node; Node* current_node; Node* last_node; size_t m_size; public: class iterator { public: iterator(Node* it = nullptr) : it{ it } {} iterator& operator=(const iterator& rhs) { it = rhs.it; return *this; } iterator& operator++() { it = it->next; return *this; } iterator operator++(int) { iterator tmp(*this); ++(*this); return tmp; } iterator& operator--() { it = it->previous; return *this; } iterator operator--(int) { iterator tmp(*this); --(*this); return tmp; } T& operator*() { return it->value; } bool operator!=(const iterator& rhs) const { return it != rhs.it; } private: friend class List; Node* getPtrNode() { return it; } Node* it; }; class reverse_iterator { public: reverse_iterator(Node* it = nullptr) : it{ it } {} reverse_iterator& operator=(const reverse_iterator& rhs) { it = rhs.it; return *this; } reverse_iterator& operator++() { it = it->previous; return *this; } reverse_iterator operator++(int) { reverse_iterator tmp(*this); ++(*this); return tmp; } reverse_iterator& operator--() { it = it->next; return *this; } reverse_iterator operator--(int) { reverse_iterator tmp(*this); --(*this); return tmp; } T& operator*() const { return it->value; } bool operator!=(const reverse_iterator& rhs) const { return it != rhs.it; } private: friend class List; Node* getPtrNode() { return it; } Node* it; }; public: List() : first_node{ nullptr }, current_node{ nullptr }, last_node{ nullptr }, m_size{} {} List(size_t n, const T& val) : first_node{ nullptr }, current_node{ nullptr }, last_node{ nullptr }, m_size{} { for (int i{}; i < n; ++i) { push_back(val); } } List(std::initializer_list l) : first_node{ nullptr }, current_node{ nullptr }, last_node{ nullptr }, m_size{} { for (const auto& it : l) { push_back(it); } } List(const List& x) : first_node{ nullptr }, current_node{ nullptr }, last_node{ nullptr }, m_size{} { Node* ptr_tmp_node{ x.first_node }; while (ptr_tmp_node != nullptr) { push_back(ptr_tmp_node->value); ptr_tmp_node = ptr_tmp_node->next; } } void push_back(const T& value) { Node* ptr_tmp_node{ new Node }; if (m_size == 0) { first_node = ptr_tmp_node; current_node = ptr_tmp_node; last_node = ptr_tmp_node; ptr_tmp_node->previous = nullptr; ptr_tmp_node->next = nullptr; ptr_tmp_node->value = value; } else { current_node->next = ptr_tmp_node; last_node = ptr_tmp_node; ptr_tmp_node->next = nullptr; ptr_tmp_node->previous = current_node; ptr_tmp_node->value = value; current_node = ptr_tmp_node; } m_size++; } iterator erase(iterator position) { iterator it{ begin() }; while (it != position) { it++; } Node* ptr_current_node = it.getPtrNode(); Node* ptr_previous_node = ptr_current_node->previous; Node* ptr_next_node = ptr_current_node->next; ptr_previous_node->next = ptr_next_node; ptr_next_node->previous = ptr_previous_node; delete ptr_current_node; m_size--; return iterator(ptr_next_node); } iterator begin() const { return iterator(first_node); } iterator end() const { return iterator(last_node->next); } reverse_iterator rbegin() const { return reverse_iterator(last_node); } reverse_iterator rend() const { return reverse_iterator(first_node->previous); } void clear() { while (first_node != nullptr) { Node* ptr_tmp{ first_node }; first_node = first_node->next; delete ptr_tmp; } first_node = nullptr; last_node = nullptr; m_size = 0; } bool empty() const { return m_size == 0; } size_t size() const { return m_size; } ~List() { while (first_node != nullptr) { Node* ptr_tmp_node{ first_node }; first_node = first_node->next; delete ptr_tmp_node; } } }; int main() { using namespace std; // Examples List f{ 500, 200, 400, 300, 100, 100, 100, 200, 300 }; // initializer List List s(f); // copy constructor for (auto it{ f.begin() }; it != f.end(); ++it) { cout << *it << ' '; } cout << endl; List::iterator it{ f.begin() }; // iterator of begin List f it++; it = f.erase(it); // erased second element for (it = f.begin(); it != f.end(); ++it) { cout << *it << ' '; } cout << endl; // increased each element of List for (it = f.begin(); it != f.end(); ++it) { (*it)++; } // range-based for loop for (const auto& it : f) { cout << it << ' '; } cout << endl; return 0; }