doubly_linked_list.hpp

Ir para a documentação deste ficheiro.

#pragma once
#include <stddef.h>
 
template <class T>
class DoublyLinkedList {
 private:
  struct Node {
    Node(const T &value);
 
    ~Node();
 
    T value;     
    Node *next;  
    Node *prev;  
  };
 
 public:
  template <class U>
  class Iterator {
   public:
    auto &operator*() const;
 
    Iterator<U> &operator++();
 
    Iterator<U> &operator--();
 
    bool operator==(const Iterator<U> &other) const;
 
    bool operator!=(const Iterator<U> &other) const;
 
    Iterator<U> operator+(size_t offset) const;
 
    Iterator<U> operator-(size_t offset) const;
 
    size_t operator-(const Iterator<U> other) const;
 
   private:
    Iterator(U *ptr, bool end);
 
    U *node;   
    bool end;  
 
    friend class DoublyLinkedList;
  };
 
  using iterator = DoublyLinkedList<T>::Iterator<Node>;
  using const_iterator = DoublyLinkedList<T>::Iterator<const Node>;
 
  DoublyLinkedList();
 
  DoublyLinkedList(const DoublyLinkedList &list);
 
  DoublyLinkedList &operator=(const DoublyLinkedList &list);
 
  ~DoublyLinkedList();
 
  size_t size() const;
 
  bool empty() const;
 
  const_iterator begin() const;
 
  const_iterator end() const;
 
  iterator begin();
 
  iterator end();
 
  void push_front(const T &value);
 
  void push_back(const T &value);
 
  void insert(iterator pos, const T &value);
 
  void pop_front();
 
  void pop_back();
 
  void erase(iterator first, iterator last);
 
  void clear();
 
  const_iterator find(const T &item) const;
 
  iterator find(const T &item);
 
  bool contains(const T &item) const;
 
  T &operator[](size_t index);
 
  const T &operator[](size_t index) const;
 
  void print() const;
 
 private:
  Node *head;   
  Node *tail;   
  size_t _size; 
};
 
#include "../src/doubly_linked_list.hpp"