Ошибка при компиляции шаблонного вектора

#include <cstring>
#include <iostream>
#include <cassert>
using namespace std;
 
template < class T > class Vector
{
private:
    T* mas;
    int size;
    int capacity;
public:
    Vector(); 
    Vector(int);
    Vector(const T*,int);
    Vector(const Vector&);
    ~Vector();
    int getSize() const;
    int getCapacity() const;
    /* double get(int pos) const
    {
        return mas[pos];
    }
    void set(double val, int pos)
    {
        mas[pos] = val;
        if (pos>=size)
        {
            size++;
        }
    } */
    void insert(T, int);
    void erase(int);
    T& operator  []  (int pos) 
    {
        return  mas[pos];
    } 
    const T& operator [] (int pos) const
    {
        return mas[pos];
    }
    template < T > friend bool operator == (const Vector<T>&, const Vector<T>&);
    template < T > friend bool operator == (const Vector<T>&, T op1);
    template < T > friend bool operator != (const Vector<T>&, const Vector<T>&);
    template < T > friend bool operator != (const Vector<T>&, T op1);
 
    template < T > friend ostream& operator << (ostream&, const Vector< T >);
};
 
template < class T > Vector< T >::Vector()
{
    capacity = 10;
    size = 0;
    mas = new T [capacity];
}
template < class T > Vector< T >::Vector(int capacity)
{
    size=0;
    this -> capacity = capacity;
    mas = new T [capacity];
}
template < class T > Vector< T >::Vector(const T* ptr,int size)
{
    this->size = size;
    capacity = size+1;
    mas = new T[capacity];
    for(int i = 0; i<=size; i++)
    {
        mas[i]=ptr[i];
    }
}
template < class T > Vector< T >::Vector(const Vector &a)
{
    size=a.size;
    capacity=a.capacity;
    mas = new T[capacity];
    for(int i = 0; i<=size; i++)
    {
        mas[i]=a.mas[i];
    }
}
template < class T > Vector< T >::~Vector()
{
    delete[] mas;
}
template < class T > int Vector< T >::getSize() const
{
    return size;
}
template <  class T > int Vector< T >::getCapacity() const
{
    return capacity;
}
template < class T > void Vector< T >::insert(T val, int pos)
{
    if(size == capacity)
    {
        this ->mas = new T [capacity*=2];
        for(int i = 0; i<size; i++)
            this -> mas[i]=mas[i];
    }
    for(int i=size; i>pos; i--)
    {
        mas[i]=mas[i-1];
    }
    mas[pos]=val;
    size++;
}
template < class T > void Vector< T >::erase(int pos)
{
    for(int i=pos; i<size; i++)
        this -> mas[i] = this -> mas[i+1];
    size--;
}
template < class T > bool operator == (const Vector<T> &ob1,const Vector<T> &ob2)
{
        if(ob1.size!=ob2.size)
        {
                return false;
 
                for(int i=0; i<=ob1.size; ++i)
                {
                        if(ob1.mas[i] != ob2.mas[i])
                        {
                                return false;
                        }
                }
                return true;
        }
}
template < class T > bool operator == (const Vector<T> &ob1, T op1)
{
        int i;
        for(i=0; i<=ob1.size; ++i) 
        {
                if(ob1.mas[i] != op1)
                {
                        return false;
                }
        }
        return true;
}
template < class T > bool operator != (const Vector<T> &ob1,const Vector<T> &ob2)
{
        return !(ob1 == ob2);
}
 
template < class T > bool operator != (const Vector<T> &ob1, T op1)
{
        return !(ob1 == op1);
}
 
int main()
{
    return 0;
}

struct day_in_year{
    int month, day;
    day_in_year(int d=1, int m=1):day(d),month(m){}
};
 
std::ostream& operator<<(std::ostream& out, const day_in_year& diy){
    out << diy.day << "." << diy.month;
        return out;
}
 
int main(){
    Vector<day_in_year> v;
    cout << v << "\n";
 
    v.insert(day_in_year(18,05), 0);
    v.insert(day_in_year(19,05), 1);
    cout << v << "\n";
    cout << v.getSize() << "\n";
 
    v[0] = day_in_year(20,05);
    cout << v[0] << "\n";
 
    v.erase(0);
    cout << v.getSize() << "\n";
    cout << v[0] << "\n";
 
    return 0;
}

    template < class T > friend bool operator == (const Vector<T>&, const Vector<T>&);
    template < class T > friend bool operator == (const Vector<T>&, T op1);
    template < class T > friend bool operator != (const Vector<T>&, const Vector<T>&);
    template < class T > friend bool operator != (const Vector<T>&, T op1);
    template < class T > friend ostream& operator << (ostream&, const Vector< T >);