How to use iterators within a template

[cppnoob781437]

Hi, I'm working on a vector class that is basically supposed to work the same way as the actual vector class in the c++ library. I have started to make the outline of the code but am having some issues understand the syntax of templates and iterators. Can someone help me? I am also pretty sure that my typedef declarations in the beginning are wrong. Any help on those would also be appreciated.

#include <string>
#include <iterator>
#pragma once

using namespace std;


template <class T>
class Vector
{
public:
	typedef size_t size_type;
	typedef T& reference;
	typedef const reference const_reference;
	typedef T value_type;
	class Vector<T>::iterator InputIterator;
	Vector();
	Vector(size_type n);
	Vector(const Vector& x);
	Vector& operator=(const Vector& x);
	iterator begin();
	iterator end();
	size_type size() const;
	void resize(size_type n);
	size_type capacity() const;
	bool empty() const;
	void reserve(size_type n);
	reference operator[](size_type n);
	const_reference operator[](size_type n) const;
	reference at(size_type n);
	const_reference at(size_type n) const;
	reference front();
	const_reference front() const;
	reference back();
	const_reference back() const;
	value_type* data();
	const value_type* data() const;
	void push_back(const value_type& val);
	void pop_back();
	void clear();
	template<class InputIterator> Vector(InputIterator first, InputIterator last);
	~Vector();

private:
	T arr[];
	int usedSize;
	int actualSize;
};

template <class T>
Vector<T>::Vector()
{
	arr = new T[0];
}

template <class T>
Vector<T>::~Vector()
{
	delete arr;
	delete usedSize;
	delete actualSize;
}

template <class T>
Vector<T>::Vector(size_type n)
{
	arr = new T[n];
	usedSize = n;
	actualSize = n;
}

template<class T>
Vector<T>::Vector(const Vector<T> & x)
{
	arr = new T[x.size()]
	for (int i = 0; i < x.size(); i++)
	{
		arr[i] = *x.at(i);
	}
	usedSize = x.usedSize;

}

template<class T>
Vector<T> & Vector<T>::operator=(const Vector & x)
{
	// TODO: insert return statement here
}

template<class T>
iterator Vector<T>::begin()
{
	return iterator();
}

template<class T>
iterator Vector<T>::end()
{
	return iterator();
}

template<class T>
Vector<T>::size_type Vector<T>::size() const
{
	return nullptr;
}

template<class T>
void Vector<T>::resize(size_type n)
{
}

template<class T>
Vector<T>::size_type Vector<T>::capacity() const
{
	return size_type();
}

template<class T>
bool Vector<T>::empty() const
{
	return false;
}

template<class T>
void Vector<T>::reserve(size_type n)
{
}

template<class T>
Vector<T>::reference Vector<T>::operator[](size_type n)
{
	return reference();
}

template<class T>
Vector<T>::const_reference Vector<T>::operator[](size_type n) const
{
	return *this;
}

template<class T>
Vector<T>::reference Vector<T>::at(size_type n)
{
	return &T[n];
}

template<class T>
Vector<T>::const_reference Vector<T>::at(size_type n) const
{
	return const_reference();
}

template<class T>
Vector<T>::reference Vector<T>::front()
{
	return reference();
}

template<class T>
Vector<T>::const_reference Vector<T>::front() const
{
	return const_reference();
}

template<class T>
Vector<T>::reference Vector<T>::back()
{
	return *this;
}

template<class T>
Vector<T>::const_reference Vector<T>::back() const
{
	return *this;
}

template<class T>
Vector<T>::value_type* Vector<T>::data()
{
	return nullptr;
}

template<class T>
const value_type * Vector<T>::data() const
{
	return nullptr;
}

template<class T>
void Vector<T>::push_back(const value_type & val)
{
	return nullptr;
}

template<class T>
void Vector<T>::pop_back()
{
	return nullptr;
}

template<class T>
void Vector<T>::clear()
{
	return nullptr;
}

I'm getting a 'std::iterator': use of class template requires template argument list error for my begin() function as well as several 'T':undeclared identifier errors on several functions.

[cire]

I strongly suggest implementing and testing incrementally. First, implement a constructor. Then, test it and move on to another function. Forget "making an outline of the code."

Iterator:
typedef std::iterator<std::random_access_iterator_tag, T> iterator;

Line 45 is illegal.

We don't delete things we haven't allocated with new.

If we allocated something with new[], we must use delete[].