#ifndef POINTER
#define POINTER

#include <exception>



template <typename T>
class Pointer{
public:
	class InvalidPointerSize : public std::exception{};
	class PointerOutOfRange : public std::exception{};

	Pointer(unsigned int N=1) throw(InvalidPointerSize);
	Pointer(const Pointer<T> & pointer);
	Pointer(const T & t);
	Pointer & operator = (const Pointer<T> & pointer);
	~Pointer();

	T * operator->(void);
	T * operator [](unsigned int index) throw(PointerOutOfRange);
	T & operator *(void) const;

private:
	struct Data{
		unsigned int N;
		T * adress;
		unsigned int nbRef;
	};

	void free()
	{
		if((data->nbRef)==1)
		{
			(data->N==1)?delete data->adress:delete[] data->adress;
			delete data;
		}
		else data->nbRef--;
	}

	void copy(Pointer<T>::Data * data)
	{
		data->nbRef++;
		this->data = data;
	}

	Data * data;
};

template <typename T>
Pointer<T>::Pointer(unsigned int N) throw(InvalidPointerSize)
:data(new Data())
{
	if(N==0)	throw InvalidPointerSize();

	if(N==1)	data->adress = new T();
	else		data->adress = new T[N];

	data->N = N;
	data->nbRef=1;
}

template <typename T>
Pointer<T>::Pointer(const T & t)
:data(new Data())
{
	data->adress = new T(t);
	data->N = 1;
	data->nbRef=1;
}


template<typename T>
Pointer<T>::Pointer(const Pointer<T> & pointer){
	copy(pointer.data);
}

template <typename T>
Pointer<T> & Pointer<T>::operator =(const Pointer<T> & pointer)
{
	free();
	copy(pointer.data);
	return (*this);
}

template<typename T>
Pointer<T>::~Pointer(){
	free();
}

template<typename T>
T * Pointer<T>::operator->(void){
	return data->adress;
}


template<typename T>
T * Pointer<T>::operator [](unsigned int index) throw(PointerOutOfRange){
	if(index>(data->N-1)) throw PointerOutOfRange();
	return &data->adress[index];
}

template<typename T>
T & Pointer<T>::operator *(void) const{
	return (*data->adress);
}

#endif