Шаблон, вложенный в него класс и оператор вывода

template<typename T>
class MyStack2
{
    class Node1
    {
        Node1* pNext;
        T* dataPtr;
 
                //Конструктор, Деструктор
        Node1(const T& sourse, Node1* NextElem);                                                                        
        ~Node1();                                                                                                       
        
        //Перегрузка операторов
        template<typename T> friend std::ostream& operator<< (std::ostream& os, const MyStack2<T>::Node1 sourse);
 
        //Друзья
        friend class MyStack2<T>;
        template<typename T> friend std::ostream& operator<< (std::ostream& os, const MyStack2<T> &sourse);             //вывод списка, тут используем, т.к. нам нужно использовать данные класса Node1
    };
 
    Node1* head;                    //указатель на первый член нашего списка
    int counter;                        //счетчик, сколько всего элементов в стеке
 
public:
 
        //Конструктор, Деструктор
    MyStack2();                 //создание стека конктретных элементов
    ~MyStack2();                    //Деструктор
 
    void push(const T& sourse);         //Положить в стек. создаетсЯ копиЯ объекта
    T pop(void);                    //Возвращает копию объекта, сам объект удаляется
 
    //Перегрузка операторов
    template<typename T> friend std::ostream& operator<< (std::ostream& os, const MyStack2<T> &sourse);             //Оператор вывода
};
 
template<typename T> std::ostream& operator<<(std::ostream& os, const MyStack2<T> &sourse)
{
    MyStack2<T>::Node1 *tPtr = sourse.head;
    while (tPtr != nullptr)
    {
        std::cout << *tPtr;
        tPtr = tPtr->pNext;
    }
    return os;
}
 
template<typename T> std::ostream& operator<<(std::ostream& os, const MyStack2<T>::Node1& sourse)
{
    os << *sourse.dataPtr;
    return os;
}

template<typename T>
class MyStack2
{
    template<typename T2> // нужна другая переменная типа.
    class Node1
    {

template<typename T> class MyStack2;
template<typename T> 
class Node1
{...};
template<typename T>
class MyStack2
{
  ...

template<typename T> friend std::ostream& operator<<(std::ostream& os, const MyStack2<T>::Node1<T>::Node1<T> &sourse);

template<typename T>
class MyStack2
{
    template<typename T2>
    class Node1
    {
        Node1<T2>* pNext;
        T2* dataPtr;
 
        Node1(const T2& sourse, Node1<T2>* NextElem);                                                                                                   
        ~Node1();                                                                                                                                       
        
        //Перегрузка операторов
        template<typename T> friend std::ostream& operator<<(std::ostream& os, const MyStack2<T>::Node1<T>::Node1<T> &sourse);                          //вывод данных страницы
 
        //Друзья
        friend class MyStack2<T2>;
        template<typename T> friend std::ostream& operator<< (std::ostream& os, const MyStack2<T> &sourse);                                             //вывод списка, тут используем, т.к. нам нужно получать данные класса Node1
    };
 
    Node1<T>* head;                     //указатель на первый член нашего списка
    int counter;                        //счетчик, сколько всего элементов в стеке
 
public:
 
    MyStack2();                     
    ~MyStack2();                        
 
    void push(const T& sourse);         //Положить в стек. создаетсЯ копиЯ объекта
    T pop(void);                        //Возвращает копию объекта, сам объект удаляется
 
    //Перегрузка операторов
    template<typename T> friend std::ostream& operator<< (std::ostream& os, const MyStack2<T> &sourse);             //Оператор вывода
};

 template<typename T2> friend std::ostream& operator<<(std::ostream& os, const MyStack2<T2>::Node1<T2>::Node1<T2> &sourse);

template <typename T> class Vector;
 
template <typename T>
std::ostream & operator << (std::ostream &os, const Vector<T> &);
 
template <typename T>
class Vector
{
private:
    T * data;
    int size;
public:
    Vector(int);
    ~Vector() { delete[] data; }
    friend std::ostream& operator << <T>(std::ostream& os, const Vector<T> &v);
};
 
template <typename T>
Vector<T>::Vector(int n)
{
    size = n;
    data = new T[size];
    for (int i = 0; i < size; i++)
        data[i] = i;
}
 
template <typename T>
std::ostream & operator << (std::ostream &os, const Vector<T> &V)
{
    for (int i = 0; i < V.size; i++)
        os << V.data[i];
    return os;
}
 
int main()
{
    Vector<int> a(5);
    std::cout << "A: " << a << std::endl;
}

template <typename T>
class Vector
{
private:
    T * data;
    int size;
public:
    Vector(int);
    ~Vector() { delete[] data; }
 
    // Implementation must be out of class!!!!
    template <typename U>
    friend std::ostream& operator <<(std::ostream &, const Vector<U> &);
};
 
template <typename T>
Vector<T>::Vector(int n)
{
    size = n;
    data = new T[size];
    for (int i = 0; i < size; i++)
        data[i] = i;
}
 
template <typename U>
std::ostream& operator <<(std::ostream &os, const Vector<U> &v) {
   for (int i = 0; i < v.size; i++)
       os << v.data[i];
   return os;
}
 
int main()
{
    Vector<int> a(5);
    std::cout << "A: " << a << std::endl;
}

template<typename T>
class MyStack2
{
    template<typename T3>
    class Node1
    {
        Node1* pNext;
        T3* dataPtr;
 
                //Конструктор, Деструктор
        Node1(const T3& sourse, Node1* NextElem);                                                                        
        ~Node1();                                                                                                       
        
        //Перегрузка операторов
        template<typename T2> 
        friend std::ostream& operator<< (std::ostream& os, const Node1<T2>& sourse)
        {
            os << *sourse.dataPtr;
            return os;
        }
        //Друзья
        friend class MyStack2<T>;
        template<typename T2> friend std::ostream& operator<< (std::ostream& os, const MyStack2<T2> &sourse);             //вывод списка, тут используем, т.к. нам нужно использовать данные класса Node1
    };
 
    Node1<T>* head;                    //указатель на первый член нашего списка
    int counter;                        //счетчик, сколько всего элементов в стеке
 
public:
 
        //Конструктор, Деструктор
    MyStack2();                 //создание стека конктретных элементов
    ~MyStack2();                    //Деструктор
 
    void push(const T& sourse);         //Положить в стек. создаетсЯ копиЯ объекта
    T pop(void);                    //Возвращает копию объекта, сам объект удаляется
 
    //Перегрузка операторов
    template<typename T> friend std::ostream& operator<< (std::ostream& os, const MyStack2<T> &sourse);             //Оператор вывода
};
 
 
template<typename T> std::ostream& operator<<(std::ostream& os, const MyStack2<T> &sourse)
{
    MyStack2<T>::Node1 *tPtr = sourse.head;
    while (tPtr != nullptr)
    {
        std::cout << *tPtr;
        tPtr = tPtr->pNext;
    }
    return os;
}