Question being asked: Please implement the following functions in C++ for linked list iterators.

(Can add more functions to implement) :

ListIterator.h

template

class ListIterator :public Iiterator

{

protected:

ListNode *node_ = nullptr;

bool done_ = true;

protected:

ListIterator() = default;

virtual ~ListIterator() = default;

ListIterator(const ListIterator & copy) noexcept;

ListIterator(ListIterator && copy) noexcept;

public:

ListIterator & operator=(const ListIterator & rhs) noexcept;

ListIterator & operator= (ListIterator && rhs ) noexcept;

T & operator * () const noexcept (false);

virtual ListNode *operator = (ListNode * const rhs) noexcept = 0;

public:

bool IsDone() const noexcept override;

T & GetCurrent() const noexcept (false) override ;

};

Iiterator.h

template

class Iiterator

{

public:

virtual void MoveNext() noexcept = 0;

virtual void Reset()noexcept = 0;

virtual bool IsDone() const noexcept = 0;

virtual T& GetCurrent() const noexcept (false) = 0;

};

ForwardIterator.h

template

class ForwardIterator : public ListIterator

{

public:

ForwardIterator() = default;

~ForwardIterator() = default;

ForwardIterator(const ForwardIterator & copy) noexcept : node_{ copy.node_ }, done_{ copy.done_ } {}

ForwardIterator(ForwardIterator && copy) noexcept;

ForwardIterator(ListNode * const node) noexcept;

ForwardIterator & operator=(const ForwardIterator & rhs) noexcept;

ForwardIterator & operator=(ForwardIterator && rhs)noexcept;

ListNode & operator=(ListNode * const rhs) noexcept override;

ForwardIterator &operator++()noexcept;

ForwardIteratoroperator++(int)noexcept;

bool operator==(ForwardIterator& rhs)noexcept { return this->node_ == rhs.node_; }

bool operator!=(ForwardIterator & rhs) noexcept { return this->node_ != rhs.node; }

public:

void MoveNext() noexcept override;

void Reset() noexcept override;

};

BackwardIterator.h

template

class BackwardIterator : public ListIterator

{

public:

BackwardIterator() = default;

~BackwardIterator ()= default;

BackwardIterator(const BackwardIterator & copy) noexcept;

BackwardIterator(BackwardIterator && copy) noexcept;

BackwardIterator(ListNode * const node) noexcept;

BackwardIterator & operator=( const BackwardIterator & rhs) noexcept;

BackwardIterator & operator=(BackwardIterator && rhs)noexcept;

ListIterator* operator=( ListNode * const rhs ) noexcept;

BackwardIterator&operator++()noexcept;

BackwardIterator operator++(int)noexcept;

bool operator==(BackwardIterator & rhs)noexcept { return this->node_ == rhs.node_; }

bool operator!=(BackwardIterator & rhs) noexcept { return this->node_ != rhs.node; }

public:

void MoveNext() noexcept override;

void Reset() noexcept override;

};

ListNode.h

#pragma once

#ifndef LISTNODE_H

#define LISTNODE_H

#include "Node.h"

template

class ListNode final : public Node

{

private:

ListNode * next_{ nullptr };

ListNode* previous_{ nullptr };

public:

ListNode() = default;

explicit ListNode(T const& data, ListNode* next = nullptr, ListNode* previous = nullptr) noexcept :

Node{ data }, next_{ next }, previous_{ previous } {}

~ListNode() = default;

ListNode(ListNode const& copy) noexcept = delete;

ListNode(ListNode&& copy) noexcept = delete;

ListNode& operator=(ListNode const & rhs) noexcept = delete;

ListNode& operator=(ListNode && rhs) noexcept = delete;

ListNode * GetNext() const noexcept;

ListNode * GetPrevious() const noexcept;

void SetNext(ListNode * const next) noexcept;

void SetPrevious(ListNode * const prev) noexcept;

};

template

ListNode* ListNode::GetNext() const noexcept

{

return next_;

}

template

ListNode* ListNode::GetPrevious() const noexcept

{

return previous_;

}

template

void ListNode::SetNext(ListNode* const next) noexcept

{

next_ = next;

}

template

void ListNode::SetPrevious(ListNode* const prev) noexcept

{

previous_ = prev;

}

#endif