Pasted

// linked_list.h
 
#ifndef LINKED_LIST_H_INCLUDED
#define LINKED_LIST_H_INCLUDED
 
// note: implementation required for pass
 
class linked_list 
{
   linked_list(linked_list&& rhs) = delete;
   linked_list(const linked_list& rhs) = delete;
   linked_list& operator=(const linked_list &rhs) = delete;
   linked_list& operator=(linked_list&& rhs) = delete;
    struct node
    {
        node();
        node(int value, node* next);
 
        int value_ = 0;
        node* next_ = nullptr;
    };
public:
   linked_list();
   ~linked_list();
 
   void push_front(int value);
   void push_back(int value);
   void insert(int value, int index);
   void pop_front();
   void pop_back();
   void remove(int index);
   void clear();
   int size() const noexcept;
   int front() const noexcept;
   int back() const noexcept;
   int at(int index) const noexcept;
   node* getNodeAt(int index) const noexcept;
   bool empty() const noexcept;
   bool isInRange(int index) const noexcept;
 
private:
   int count_;
   node *head_;
   node *tail_;
};
 
#endif // !LINKED_LIST_H_INCLUDED
 
// linked_list.cpp
 
#include "linked_list.h"
 
linked_list::node::node(int value, node *next)
   : value_(value)
   , next_(next)
{
 
}
 
linked_list::linked_list() 
   : count_(0)
   , head_(nullptr)
   , tail_(nullptr)
{
 
}
 
linked_list::~linked_list()
{
    clear();
}
 
void linked_list::push_front(int value) {
    head_ = new node{ value, head_ };
    if (empty()){
        tail_ = head_;      
    }
    count_++;
}
 
void linked_list::push_back(int value) {
    node* Tmp_Node = new node{ value, nullptr };
    if (empty()) {      
        head_ = Tmp_Node;       
    }else{          
        tail_->next_ = Tmp_Node;
    }
    tail_ = Tmp_Node;
    count_++;
}
 
void linked_list::insert(int value, int index)
{
    if (!(isInRange(index) || index == count_)){ //WARNING, count_ should not be valid. The test is wrong.
        return;
    }
    if (index == 0){        
        return push_front(value);
    }
    if (index == count_) { // If index is after tail. TODO: probably a logic error.     
        return push_back(value);
    }   
    node* infront = getNodeAt(index - 1);
    node* after = infront->next_;
    infront->next_ = new node{ value, after };  
    count_++;       
}
 
void linked_list::pop_front()
{
    if (empty()) {
        return; //TODO: do we want pop_front on empty containers to be allowed? consider exceptions
    }
    if (count_ == 1) // If the list has only 1 node.
    {
        delete head_;
        head_ = nullptr;
        tail_ = nullptr;
        count_--;
        return;
    }
    else // If the list has more than 1 node.
    {
        node* Tmp_Node;
        Tmp_Node = head_->next_;
        delete head_;
        head_ = Tmp_Node;
        count_--;
        return;
    }
    
}
 
void linked_list::pop_back(){
    if (empty()) {
        return;//TODO: pop back on empty should be undefined behavior
    }   
    /*node* secondToLast = getNodeAt(size() - 1);   
    delete tail_;
    secondToLast->next_ = nullptr;
    tail_ = secondToLast;
    count_--;
    if (empty()) {
        head_ = nullptr;
        tail_ = nullptr;
    }*/
    if (count_ == 1) // If the list has 1 node.
    {
        delete tail_;
        tail_ = nullptr;
        head_ = nullptr;
        count_--;
        return;
    }
    else // If list has more than 1 node.
    {
        node* Tmp_CurrentNode = head_;
        node* Tmp_PreviousNode = head_; // Initialized as head just to avoid warnings.
        int IterationCounter = 0;
 
        while (Tmp_CurrentNode != tail_)
        {
            if (IterationCounter == (count_ - 2)) // Captures the before last node.
            {
                Tmp_PreviousNode = Tmp_CurrentNode;
            }
 
            Tmp_CurrentNode = Tmp_CurrentNode->next_;
            IterationCounter++;
        }
 
        delete Tmp_CurrentNode;
        Tmp_PreviousNode->next_ = nullptr;
        tail_ = Tmp_PreviousNode;
        count_--;
        return;
    }
}
 
void linked_list::remove(int index) 
{
    if (isInRange(index)) // Validates if index exists in the list.
    {
        node* Tmp_Node;
 
        if (index == 0) // If index is head.
        {
            if (head_->next_ == nullptr) // If there is nothing after the head.
            {
                delete head_;
                head_ = nullptr;
                tail_ = nullptr;
                count_--;
                return;
            }
            else // If there is something after the head.
            {
                Tmp_Node = head_->next_;
                delete head_;
                head_ = Tmp_Node;
                count_--;
                return;
            }
        }
 
        node* Tmp_CurrentNode = head_;
        node* Tmp_PreviousNode = head_; // Initialized as head just to avoid warnings.
        int IterationCounter = 0;
 
        if (index == (count_ - 1)) // If index is tail.
        {
            while (IterationCounter != index)
            {
                if (IterationCounter == (index - 1)) // Captures the previous node.
                {
                    Tmp_PreviousNode = Tmp_CurrentNode;
                }
 
                Tmp_CurrentNode = Tmp_CurrentNode->next_;
                IterationCounter++;
            }
 
            delete Tmp_CurrentNode;
            Tmp_PreviousNode->next_ = nullptr;
            tail_ = Tmp_PreviousNode;
            count_--;
            return;
        }
        else // If index is in the middle.
        {
            while (IterationCounter != index) 
            {
                if (IterationCounter == (index - 1)) // Captures the previous node.
                {
                    Tmp_PreviousNode = Tmp_CurrentNode;
                }
 
                Tmp_CurrentNode = Tmp_CurrentNode->next_;
                IterationCounter++;
            }
 
            Tmp_Node = Tmp_CurrentNode->next_;
            delete Tmp_CurrentNode;
            Tmp_PreviousNode->next_ = Tmp_Node;
            count_--;
            return;
        }
    }
}
 
void linked_list::clear(){  
    while (!empty()) {
        pop_back(); //assumes pop_back assigns nullptr to members when empty 
    }
}
 
int linked_list::size() const noexcept {
   return count_;
}
 
int linked_list::front() const noexcept {
    if (head_ == nullptr){
        return -1;  //WARNING: error sentinel value is a valid int value.   
    }
    return head_->value_;
}
 
int linked_list::back() const noexcept {
    if (tail_ == nullptr){
        return -1;  //WARNING: error sentinel value is a valid int value.   
    }
    return tail_->value_;   
}
 
int linked_list::at(int index) const noexcept {
    if (!isInRange(index)) {        
        return -1; //WARNING: error sentinel value is a valid value.        
        //invalid indexes should perhaps throw an exception, or assert.
    }
    node* tmp = getNodeAt(index);
    return tmp ? tmp->value_ : -1;
}
 
linked_list::node* linked_list::getNodeAt(int index) const noexcept {
    if (!isInRange(index)) {
        return nullptr;
    }
    node* temp = head_;
    for (int i = 0; i < index && temp->next_; i++) {
        temp = temp->next_;
    }
    return temp;
}
 
bool linked_list::empty() const noexcept{
    return count_ <= 0; //TODO: change count_ to std::size_t
}
 
bool linked_list::isInRange(int index) const noexcept{
    return !empty() && index > -1 && index < size();        
}