#include <iostream>
using namespace std;

template<class T> 
class Vektor
{
	private:
		T *data;
		unsigned int groesse;
	public:
		Vektor(unsigned int Groesse);
		Vektor(Vektor<T> const& v);
		Vektor(){};
		void print();
		friend ostream& operator<<(ostream& o, const Vektor<T>& other);
		Vektor<T> operator=(Vektor<T> const& v);
		Vektor<T> operator+(Vektor<T> const& v) const ;
		Vektor(unsigned int groesse, T* daten);
		T const& operator[](unsigned int const index) const ;
		T & operator[](unsigned int const index) ;
		unsigned int Groesse() const   { return groesse; };
};

template <class T>
ostream& operator<<(ostream& o, const Vektor<T>& other)
{       
      for(int i=0; i<other.groesse; i++)
        {
                o << other.data[i] << endl;
        }

        return o;
}

template <class T>
Vektor<T> :: Vektor(Vektor<T> const& v)
{
	data = v.data;
	groesse = v.groesse;
}

template<class T> 
void  Vektor<T> :: print()
{
	for(int i=0; i<groesse; i++)
        {
                cout << data[i] << endl;
        }
}


template<class T> 
Vektor<T> :: Vektor(unsigned int Groesse, T* daten)
{ 
	data = new T[Groesse];
	groesse = Groesse;
	for(unsigned int i = 0; i < groesse; i++)
		data[i]=daten[i]; 
}

template<class T>
Vektor<T>::Vektor(unsigned int Groesse)
{
	groesse = Groesse;
	data = new T[Groesse];
}
template<class T>
Vektor<T> Vektor<T>::operator+(Vektor<T> const& v) const
{
	if (groesse!=v.groesse)
		throw "falsche Laenge"; 
	
	Vektor<T> Ergebnis(groesse);
	for (unsigned int position=0;position<groesse; position++)
		Ergebnis[position] = data[position]+v[position];
	
	return Ergebnis;
}

template <class T>
Vektor<T> Vektor<T>::operator=(Vektor<T> const& v)
{
	if (groesse!=v.groesse)
		throw "falsche Laenge"; 
	
	this->data=v.data;
	this->groesse = v.groesse;
	
	return *this;
}

template<class T>
T const& Vektor<T>::operator[](unsigned int const index) const
{ 
	return data[index]; 
}

template<class T>
T & Vektor<T>::operator[](unsigned int const index)
{ 
	return data[index]; 
}