Iterators, ADT's

[brinkley182]

3) Write a program that uses a List ADT to store the numbers 10, 15, 25, 35, 70, 100, and 101. Write a function for your program named addToEach that takes an integer value passed from the user and adds that value to each number stored in your ADT. Design and implement your code such that you can switch between using the Vector and Doubly-Linked List implementations of the List ADT by changing at most 2 lines of code in your program (hint - iterators are your friends!)

4) Extend your work from 1 and 2 to create a Stack Class and a Queue Class (I don't care which implementation you use, just make sure you're structuring things in such a way that the required operations are performed in O(1) time)

I do not quite understand how to make use of iterators in this scenario. Also does it matter if I extend VectorADT(part 1) or List(part 2) for part 4.

//doubly linked list
template <typename Object>
class List
{
private:
	struct Node
	{
		Object data;
		Node *prev;
		Node *next;
		Node(const Object & d = Object{}, Node * p = nullptr, Node * n = nullptr) : data{ d }, prev{ p }, next{ n } {}
		Node(Object && d, Node * p = nullptr, Node * n = nullptr) : data{ std::move(d) },prev{p},next{n}{}

	};
public:
	class const_iterator
	{
	public:
		const_iterator() :current{ nullptr } {}
		const Object & operator*() const
		{
			return retrieve();
		}
		const_iterator & operator++()
		{
			current = current->next;
			return *this;
		}
		const_iterator operator++(int)
		{
			const_iterator old = *this;
			++(*this);
			return old;
		}
		bool operator==(const const_iterator & rhs)const
		{
			return current == rhs.current;
		}
		bool operator!=(const const_iterator & rhs)const
		{
			return !(*this == rhs);
		}
	protected:
		Node *current;
		Object & retrieve()const
		{
			return current->data;
		}
		const_iterator(Node *p): current{p}{}
		friend class List<Object>;
	};
	class iterator : public const_iterator
	{

	public:
		iterator()
		{}
		Object & operator*()
		{
			return const_iterator::retrieve();
		}
		const Object & operator*() const
		{
			return const_iterator::operator*();
		}
		iterator & operator++()
		{
			this->current = this->current->next;
			return *this;
		}
		iterator operator++(int)
		{
			iterator old = *this;
			++(*this);
			return old;
		}
	protected:
		iterator(Node *p) :const_iterator{ p } {}
		friend class List<Object>;

	};
	List()
	{
		init();
	}
	~List()
	{
		clear();
		delete head;
		delete tail;
	}
	List(const List & rhs)
	{
		P
			init();
		for (auto & x : rhs)
			push_back(x);
	}
	List & operator=(const List & rhs)
	{
		List copy = rhs;
		std::swap(*this, copy);
		return *this;
	}
	List(List && rhs) : theSize{ rhs.theSize }, head{ rhs.head }, tail{ rhs.tail }
	{
		rhs.theSize = 0;
		rhs.head = nullptr;
		rhs.tail = nullptr;
	}
	List & operator=(List && rhs)
	{
		std::swap(theSize, rhs.theSize);
		std::swap(head, rhs.head);
		std::swap(tail, rhs.tail);
	}

	iterator begin()
	{
		return{ head->next };
	}
	const_iterator begin() const
	{
		return{ head->next };
	}
	iterator end()
	{
		return{ tail };
	}
	const_iterator end() const
	{
		return{ tail };
	}
	int size()const
	{
		return theSize;
	}
	bool empty() const
	{
		return size() == 0;
	}
	void clear()
	{
		while (!empty())
			pop_front();
	}
	Object & front()
	{
		return *begin();
	}
	const Object & front()const
	{
		return *begin();
	}
	Object & back()
	{
		return *--end();
	}
	const Object & back() const
	{
		return *--end();
	}
	void push_front(const Object & x)
	{
		insert(begin(), x);
	}
	void push_front(Object && x)
	{
		insert(begin(), std::move(x));
	}
	void push_back(const Object & x)
	{
		insert(end(), x);
	}
	void push_back(Object && x)
	{
		insert(end(), std::move(x));
	}
	void pop_front()
	{
		erase(begin());
	}
	void pop_back()
	{
		erase(--end());
	}
	iterator insert(iterator itr, const Object & x)
	{
		Node *p = itr.current;
		theSize++;
		return{ p->prev = p->prev->next = new Node{x,p->prev,p} };
	}
	iterator insert(iterator itr, Object && x)
	{
		Node *p = itr.current;
		theSize++;
		return{ p->prev = p->prev->next = new Node{std::move(x),p->prev,p} };
	}
	iterator erase(iterator itr)
	{
		Node *p = itr.current;
		iterator retVal{ p->next };
		p->pre->next = p->next;
		p->next->prev = p->prev;
		delete p;
		theSize--;
		return retVal;

	}
	iterator erase(iterator from, iterator to)
	{
		for (iterator itr = from; itr != to; itr = erase(itr))

			return to;
	}
	void addToEach(int addTo, List x)
	{
		
		
		int length = theSize;
		for (int i = 0; i < length - 1; i++)
		{
			//error left of .data must have class/struct/union
                        //do not quite understand why that is still trying to 
                        //figure it out
			x.push_back(x.head.data+addTo);
			x.pop_front();
			


		}

	}
	private:
		int theSize;
		Node *head;
		Node *tail;
		void init()
		{
			theSize = 0;
			head = new Node;
			tail = new Node;
			head->next = tail;
			tail->prev = head;
		}
};
//Vector implementation of list
#include <iostream>
#include <algorithm>



template<typename Object>

class VectorADT
{
public:
	explicit VectorADT(int initSize = 0) : theSize{ initSize }, theCapacity{ initSize + SPARE_CAPACITY } { objects = newObject[theCapacity]; }
	VectorADT(const VectorADT &rhs) : theSize{ rhs.theSize }, theCapacity{ rhs.theCapacity }, objects{nullptr}
	{
		objects = new Object[theCapacity];
		for (int k = 0; k < theSize; ++k)
			objects[k] = rhs.objects[k];
	
	}
	VectorADT & operator=(const VectorADT & rhs)
	{
		VectorADT copy = rhs;
		std::swap(*this.copy);
		return *this;
	}
	~VectorADT()
	{
		delete[] objects;
	}
	VectorADT(VectorADT && rhs) :theSize{ rhs.theSize }, theCapacity{ rhs.theCapacity }, objects{ rhs.objects }
	{
		rhs.objects = nullptr;
		rhs.theSize = 0;
		rhs.theCapactiy = 0;
	}
	VectorADT & operator =(VectorADT && rhs)
	{
		std::swap(theSize, rhs.theSize);
		std::swap(theCapacity, rhs.theCapacity);
		std::swap(objects, rhs.objects);
		return *this;
	}
	void resize(int newSize)
	{
		if (newSize > theCapacity)
			reserve(newSize = 2);
		theSize = newSize;
	}
	void reserve(int newCapacity)
	{
		if (newCapacity < theSize)
			return;
		Object *newArray = newObjects[newCapacity];
		for (int k = 0; k < theSize; ++k)
			newArray[k] = std::move(objects[k]);
		theCapactiy = newCapacity;
		std::swap(objects newArray);
		delete[] newArray;
			
	}
	Object & operator[](int index)
	{
		return objects[index];
	}
	bool empty() const
	{
		return size() == 0;
	}
	int size() const
	{
		return theSize;
	}
	int capactiy() const
	{
		return theCapacity;
	}
	void push_back(const Object & x)
	{
		if (theSize == theCapacity)
			reserve(2 * theCapacity + 1);
		objects[theSize++] = x;
	}
	void push_back(Object && x)
	{
		if (theSize == theCapacity)
			reserve(2 * theCapacity + 1);
		objects[theSize++] = std::move(x);
	}
	void pop_back()
	{
		--theSize;
	}
	const Object & back() const
	{
		return objects[theSize - 1];
	}
	typedef Object * iterator;
	typedef const Object * const_iterator;
		iterator begin()
		{
			return &objects[0];
		}
		const_iterator begin() const
		{
			return &objects[0];
		}
		iterator end()
		{
			return &objects[size()];
		}
		const_iterator end() const
		{
			return &objects[size()];
		}
		void addToEach(int addTo)
		{

		}
		static const int SPARE_CAPACITY = 16;
private:
	int theSize;
	int theCapacity;
	Object * objects;





};