#pragma once

#include <cstddef>
#include <stdexcept>

template <typename T> class Array {
	public:
		Array();
		Array(unsigned int size);
		Array(const Array<T>& other);
		
		Array<T>& operator=(const Array<T>& other);

		T& operator[](unsigned int index);
		const T& operator[](unsigned int index) const;
		
		unsigned int size() const;

		~Array();
	private:
		T* data;
		unsigned int _size;
};


template <typename T> Array<T>::Array(): data(NULL), _size(0) {
}

template <typename T> Array<T>::Array(unsigned int size): data(new T[size]()), _size(size) {
}

template <typename T> Array<T>::Array(const Array<T>& other): data(new T[other._size]), _size(other._size) {
	for (unsigned int i = 0; i < _size; ++i)
		data[i] = other.data[i];
}

template <typename T> Array<T>& Array<T>::operator=(const Array<T>& other) {
	if (this == &other)
		return *this;

	delete[] data;
	data = new T[other._size];
	_size = other._size;
	for (unsigned int i = 0; i < _size; ++i)
		data[i] = other.data[i];

	return *this;
}

template <typename T> T& Array<T>::operator[](unsigned int index) {
	if (index >= _size)
		throw std::out_of_range("Array index out of range");

	return data[index];
}

template <typename T> const T& Array<T>::operator[](unsigned int index) const {
	if (index >= _size)
		throw std::out_of_range("Array index out of range");

	return data[index];
}

template <typename T> unsigned int Array<T>::size() const {
	return _size;
}

template <typename T> Array<T>::~Array() {
	delete[] data;
}