Implementation of doubly linked list

      DoublyLinkedList():front(nullptr),back(nullptr),cur(nullptr),size(0) {}
      DoublyLinkedList(const DoublyLinkedList& a) {
        front = back = cur = nullptr;
        this* = a;
      }
      void goFront() { cur = front; }
      void goBack() { cur = back; }
      void goNext() {
        if ( cur == back )
          throw(AT_BACK);
        cur = cur->next;
      }
      void goPrev() {
        if ( cur == front )
          throw(AT_FRONT);
        cur = cur->prev;
      }
      int getValue() const {
        if ( !cur )
          throw(LIST_EMPTY);
        return cur->data;
      }
      void setValue(int d) {
        if ( !cur )
          throw(LIST_EMPTY);
        cur->data = d;
      }
      void insertBefore(int d) {
        auto newNode = new Node( d );
        if ( cur ) {
          newNode->next = cur;
          if ( cur->prev ) {
            newNode->prev = cur->prev;
            cur->prev->next = newNode;
            cur->prev = newNode;
          }
          else {
            cur->prev = newNode;
            front = newNode;
          }
          cur = newNode;
        }
        else
          front = cur = back = newNode;
        size++;
      }
      void insertAfter(int d) {
        auto newNode = new Node( d );
        if ( cur ) {
          newNode->prev = cur;
          if ( cur->next ) {
            newNode->next = cur->next;
            cur->next->prev = newNode;
            cur->next = newNode;
          }
          else {
            cur->next = newNode;
            back = newNode;
          }
          cur = newNode;
        }
        else
          front = cur = back = newNode;
        size++;
      }
      void erase() {
        if ( cur ) {
          auto t = cur;
          if ( cur->next)
            cur->next->prev = cur->prev;
          else
            back = back->prev
          if ( cur->prev )
            cur->prev->next = cur->next;
          else
            front = front->next;
          cur = cur->next;
          delete t;
          size–;
        }
      }
      bool isEmpty() const { return !size; }
      unsigned int getSize() const { return size; }
      void pushFront(int d) {
        auto newNode = new DLLNode();
        newNode->next = front;
        newNode->data = d;
        front = newNode;
        size++;
      }
      void pushBack(int d){
        auto newNode = new DLLNode();
        newNode->prev = back;
        newNode->data = d;
        back = newNode;
        size++;
      }
      void popFront() {
        if ( front == back )
          front = nullptr;
        if ( front == cur )
          cur = cur->next;
        auto t = front;
        front = front->next;
        delete t;
        size–;
      }
      void popBack() {
        if ( front == back )
          back = nullptr;
        if ( back == cur )
          cur = cur->prev;
        auto t = back;
        back = back->prev;
        delete t;
        size–;
      }
      DoublyLinkedList& operator=(const DoublyLinkedList& a){
        if ( !a.isEmpty ) {
          for ( int this->size = 0; this->size < a.size ; this->size++, a.goNext ) {
            this->pushBack(a.getValue());
          }
        return *this;
      }
      ~DoublyLinkedList() {
        if ( cur )
          erase();
      }
Advertisements

To Do3 – char* nstrcat()

char* nstrcat(char* name, …) {

char* des = name;

char* src;

while (*des) ++des;

va_list vargs;

va_start(vargs, name);

src = va_arg(vargs, char*);

while ((*des++ = *src++) != ”;

va_end(vargs);

return name;

}