Конструктор копирования для односвязного списка в данной реализации

template<typename T> class Node {
    Node<T>* pNext;
    T m_Data;
    Node():pNext(nullptr),m_Data() {
    }//default
 
    Node(Node* p_other, const T& data) :m_Data(data) {//Конструктор с параметрами
        this->pNext = p_other->pNext;
        p_other->pNext = this;
    }
    template <typename T> friend class MyStack2;
    template<typename T> friend std::ostream& operator<<(std::ostream& os, const MyStack2<T>& stack);
    template <typename T1> friend std::ostream& operator<<(std::ostream& os, const Node<T1>& node);
};
 
template <typename T1> std::ostream& operator<<(std::ostream& os, const Node<T1>& node) {
    os << node.m_Data << endl;
    return os;
}

#pragma once
#include <iostream>
#include  <ctype.h>
using namespace::std;
 
 
class MyString {
    char* str;
    void Swap(MyString&);
public:
    MyString();
    MyString(const char*);
    MyString(MyString&&);
    MyString(const MyString&);
    ~MyString();
    MyString& operator=(const MyString&);
    bool operator==(const MyString&) const;
    bool operator==(const char* key) const;
    friend ostream& operator<<(ostream&, const MyString&);
 
};

#define _CRT_SECURE_NO_WARNINGS
#include "MyString.h"
#include <iostream>
#include <cstring>
#include <cstdarg>
 
MyString::MyString(){//Default конструктор
    str = nullptr;
}
 
MyString::MyString(const char* string) {//Конструктор с параметрами
    str = new char [strlen(string) + 1];
    strcpy(str, string);
}
 
MyString::MyString(const MyString& other) {//Конструктор Копирования
    if (this != nullptr) {
        str = new char[strlen(other.str) + 1];
        strcpy(str, other.str);
    }
    else {
        str = nullptr;
    }
}
 
MyString::MyString(MyString&& other) { //move KK
    str = other.str;
    other.str = nullptr;
}
 
 
MyString::~MyString() {//Деструктор
    if (str != nullptr) {
        delete[] str;
        str = nullptr;
    }
}
 
 
MyString& MyString::operator=(const MyString& other) { //operator=
    if (other.str != nullptr) {
        str = new char[strlen(other.str)+1];
        strcpy(str, other.str);
    }
    return *this;
}
 
bool MyString::operator==(const MyString& other) const{
    return strcmp(str, other.str) == 0;
}
 
bool MyString::operator==(const char* key) const  {
    return strcmp(str, key) == 0;
}
 
ostream& operator<<(std::ostream& os, const MyString& string) { //функция вывода на экран
    if (string.str != nullptr) {
        os << string.str;
    }
    return os;
}

template<typename T > class MyStack2 {
    Node<T> Head;
    size_t size;
 
public:
        MyStack2():size(0), Head() {}
 
        void push(const T& other) {
        new Node<T>(&Head, other);
        size++;
        }
 
        T pop() {
            
            if (size == 0) { throw "EMPTY STACK"; }
                T ret = std::move(Head.pNext->m_Data);
                Node<T>* tmp = Head.pNext->pNext;
                delete Head.pNext;
                Head.pNext = tmp;
                size--;
                return ret;
        };
 
        MyStack2(const MyStack2<T>& other):size(other.size) { //Конструктор копирования?????
            Node<T>* p_other = other.Head.pNext;
            Node<T>* p_this = &Head;
            while(p_other->pNext != nullptr) {
                new Node<T>(p_other, p_other->m_Data);
                p_other = p_other->pNext;
            }
        }
 
        template<typename T> friend std::ostream& operator<<(std::ostream& os, const MyStack2<T>& stack);
};
    
template<typename T> std::ostream& operator<<(std::ostream& os, const MyStack2<T>& stack) {
    Node<T>* p = stack.Head.pNext;
    for (size_t i = 0; i < stack.size; i++) {
        std::cout << *p;
        p = p->pNext;
    }
    return os;
}

 // ну и оператор присваивания копированием
    MyStack2<T> &operator=(const MyStack2<T>& other){
        if (this != &other){
            Node<T>* left = &Head;
            const Node<T>* right = &other.Head;
            // первый цикл : копирование
            while(left->pNext && right->pNext){
                left->pNext->m_Data = right->pNext->m_Data;
                left = left->pNext;
                right = right->pNext;
            }
            // ворой циикл : создание
            while(right->pNext){
                left->pNext = new Node<T>(left, right->pNext->m_Data); // забиваем на то что твоиртся в конструкторе
                left->pNext->pNext = nullptr; // заглушка
                left = left->pNext;
                right = right->pNext;
            }
            // третий : удаление
            Node<T>* del_left = left->pNext, *pnext;
            left->pNext = nullptr; // отсекаем хвост
            while(del_left){
                pnext = del_left->pNext;
                delete del_left;
                del_left = pnext;
            }  
        }
        return *this;
    }

        this->size = other.size; // ожидаем что всё выше прошло успешно.
        return *this;