Ссылка на неразрешенный внешний символ, Ошибка средств компоновщика LNK2019

#pragma once
 
#define START 100
#include <iostream>
#include <set>
#include <algorithm>
#include <iterator>
using namespace std;
 
 
template <class T>
class Elements {
 
private:
    //int size = 0;
    //int *myarray;
    
    int Size() {
        return this->size;
    }
 
    void Clear() {
        this->size = 0;
        delete[] myarray;
    }
 
    void Swap(Elements <T> &set1, Elements <T> &set2) { ///////
        Elements <T> set3;
        set3 = set1;
        set1 = set2;
        set2 = set3;
    }
 
public:
 
    int size = 0;
    T *myarray;
 
    Elements <T>() {                             // конструктор класса
        myarray = new T[START];
        cout << "+CONSTRUCTOR+\n";
    }     
 
    Elements<T>(const Elements <T>&obj)  {      // copy constructor   
        size = obj.size;
        myarray = new T[START];
        for (int i = 0; i < size; ++i) {
            myarray[i] = obj.myarray[i];
        }
        cout << "+COPY CONSTRUCTOR+\n";
    }   
 
    explicit Elements<T>(Elements<T>&& other) {          // move constructor 
        //cout << other;
        size = other.size;
        myarray = new T[START];
        for (int i = 0; i < size; ++i) {
            myarray[i] = other.myarray[i];
        }
        other.Clear();
 
        cout << "+MOVE CONSTRUCTOR+";
    }
 
    ~Elements<T>() {                            //  деструктор
        Clear();
        cout << "+DESTRUCTOR+\n";
    }
 
    int operator [](int n) {
        return this->myarray[n];
    }
    Elements<T>& operator= (const Elements <T> &obj) {
        if (&obj == this)
            return *this;
 
        size = obj.size;
 
        for (int i = 0; i < obj.size; ++i) {
            myarray[i] = obj.myarray[i];
        }
        return *this;
    }
    friend ostream& operator<<(ostream &s, const Elements <T> & obj);
    friend istream& operator>> (istream &s, Elements <T> &obj);
    friend bool operator ==(const Elements <T> &set1, const Elements <T> &set2);
    friend bool operator !=(const Elements <T> &set1, const Elements  <T> &set2);
    friend Elements <T> operator + (const Elements <T> &set1, const Elements <T> &set2);
    friend Elements <T> operator +=(Elements <T> &set1, const Elements <T> &set2);
    friend Elements <T>operator * (const Elements <T> &set1, const Elements <T> &set2);
    friend Elements <T>operator *=(Elements <T> &set1, const Elements <T> &set2);
    void Sort(Elements <T> &set)  {
        for (int i = 0; i < set.size - 1; ++i) {
            for (int j = 0; j < set.size - i - 1; ++j) {
                if (set.myarray[j] > set.myarray[j + 1]) {
                    swap(set.myarray[j], set.myarray[j + 1]);
                }
            }
        }
    }
    friend Elements <T> operator / (const Elements <T> &set1, const Elements <T> &set2);
    friend Elements <T> operator /=(Elements <T> &set1, const Elements <T> &set2);
protected:
 
 
};
 
 
 
template <typename T>
ostream& operator<<(ostream &s, const Elements <T> & obj)     // out
{
    s << "   |   Elements: ";
 
    for (int i =0; i < obj.size; ++i) {
        s << obj.myarray[i] << " ";
    }
    s << "  |\n";
    return s;
} 
 
template <typename T>
istream& operator >> (istream &s, Elements <T> &obj)
{
    cout << "the number of elements of your set (to initialize): ";
    s >> obj.size;
 
    T t;
 
    for (int i = 0; i < obj.size; ++i) {
    cout << "element number " << i + 1 << ": ";
        s >> t;
        obj.myarray[i]=t;
    }
    Sort(obj);
    return s;
}
 
 
template <typename T>
bool operator ==(const Elements <T> &set1, const Elements <T> &set2) {
    if (set1.size != set2.size) return false;
    else {
        for (int i = 0; i < set1.size; ++i) {
            if (set1.myarray[0] != set2.myarray[0]) return false;
        }
        return true;
    }
}
 
template <typename T>
bool operator != (const Elements <T> &set1, const Elements <T> &set2) {
    return !(set1 == set2);
}
 
template <typename T>
void ChangeSize(int OldSize, int NewSize, Elements <T> &obj) {
    Elements <T> temp;
    temp.size = NewSize;
    for (int i = 0; i < min(OldSize,NewSize); ++i) {
        temp.myarray[i] = obj.myarray[i];
    }
    obj = temp;
}
 
template <typename T>
Elements<T> operator + (const Elements <T> &set1, const Elements <T> &set2) {
    Elements <T> set3;
    set3.size = set1.size + set2.size;
    ChangeSize(START, set3.size, set3);
    for (int i = 0; i < set1.size; ++i) {
        set3.myarray[i] = set1.myarray[i];
    }
    for (int i = set1.size; i < set3.size; ++i) {
        set3.myarray[i] = set2.myarray[i - set1.size];
    }
    Sort(set3);
    return set3;
}
 
template <typename T>
Elements <T> operator +=(Elements <T> &set1, const Elements <T> &set2) {
    set1 = set1 + set2;
    Sort(set1);
    return set1;
}
 
template <typename T>
int FindEleminArray(const Elements <T> &set, T el, int from) {
    for (int i = from; i < set.size; ++i) {
        if (set.myarray[i] == el) return i;
    }
    return -1;
}
 
template <typename T>
Elements <T> operator *(const Elements <T> &set1, const Elements <T> &set2) {
    Elements <T> set3;
 
    int t = 0, p = 0, m = 0;
 
    for (int t = 0; t < set1.size; ++t) {
        if (FindEleminArray(set2, set1.myarray[t], p) > -1) {
            set3.myarray[m] = set1.myarray[t];
            ++m;
            p = FindEleminArray(set2, set1.myarray[t], p) + 1;
            ++set3.size;
        }
    }
 
    Sort(set3);
    return set3;
}
 
template <typename T>
Elements <T> operator / (const Elements <T> &set1, const Elements  <T> &set2) {
    Elements <T> set3, set4;
 
    set3 = set1 * set2;
 
    // set1 - set3
 
    int p = 0, m=0;  // с какого искать в сет1
    for (int i = 0; i < set1.size; ++i) {
        if (FindEleminArray(set3, set1.myarray[i], p) < 0) {
            set4.myarray[m] = set1.myarray[i];
            ++m;
            ++set4.size;
 
        }
        else {
            p = FindEleminArray(set3, set1.myarray[i], p) + 1; 
            // или // p = FindEleminArray(set3, set1.myarray[i], p) ; 
        }
    }
 
    Sort(set4);
    return set4;
}
 
 
template <typename T>
Elements <T> operator *=(Elements <T> &set1, const Elements <T>  &set2) {
    set1 = set1 * set2;
    Sort(set1);
    return set1;
}
 
template <typename T>
Elements <T> operator /=(Elements  <T> &set1, const Elements <T>  &set2) {
    set1 = set1 / set2;
    Sort(set1);
    return set1;
}

template<typename M>
    friend ostream& operator<<(ostream &s, const Elements <M> & obj);

void Sort()
{
     for (int i = 0; i < size - 1; ++i) {
            for (int j = 0; j < size - i - 1; ++j) {
                if (myarray[j] > myarray[j + 1]) {
                    swap(myarray[j], myarray[j + 1]);
                }
            }
        }
}
 
// Вызывать так
set.Sort(); // Он отсортирован

static void Sort(Elements& set)
{
     for (int i = 0; i < set.size - 1; ++i) {
            for (int j = 0; j < set.size - i - 1; ++j) {
                if (set.myarray[j] > set.myarray[j + 1]) {
                    swap(set.myarray[j], set.myarray[j + 1]);
                }
            }
        }
}
 
Elements<int>::Sort(elements); // Отсортирован elements

template<typename T>
class A
{
public:
   A(); // Тут имеется в виду именно создание A<T>
   A returnA(); // Тут имеется ввиду, что возвращаем именно A<T>
   void getA(A a); // Тут имеется ввиду, что принимает именно A<T> 
};
 
template<typename T>
A<T> A<T>::returnA() // Мы уже не внутри класса, надо явно указать, что A<T>
{}