Перегрузка оператора присваивания

template<class T> class List
{
    class Node
    {
    public:
        T data;
        Node* next;
        Node* prev;
        Node(T n = 0) { data = n; next = nullptr; prev = nullptr; }
    };
 
    Node* pbeg, * pend;
public:
    List() { pbeg = nullptr; pend = nullptr; }
    ~List();
    void add(T data);
    Node* find(T i);
    Node* insert(T key, T data);
    bool remove(T key);
    void print();
};
 
template<class T>List<T>::~List()
{
    if (pbeg != nullptr)
    {
        Node* pv = pbeg;
        while (pv)
        {
            pv = pv->next; delete pbeg;
            pbeg = pv;
        }
    }
}
 
template<class T>void List<T>::print()
{
    Node* pv = pbeg;
    std::cout << std::endl << "list: ";
    while (pv)
    {
        std::cout << pv->data << ' ';
        pv = pv->next;
    }
    std::cout << std::endl;
}
 
template<class T> void List<T>::add(T data)
{
    Node* pv = new Node(data);
    if (pbeg == nullptr)
        pbeg = pend = pv;
    else
    {
        pv->prev = pend;
        pend->next = pv;
        pend = pv;
    }
}
 
template <typename T> typename List<T>::Node* List<T>::find(T i)
{
    Node* pv = pbeg;
    while (pv)
    {
        if (pv->data = data) break;
        pv = pv->next;
    }
    return pv;
}
 
template<typename T> typename List<T>::Node* List<T>::insert(T key, T data)
{
    if (Node* pkey = find(key))
    {
        Node* pv = new Node(data);
        pv->next = pkey->next;
        pv->prev = pkey;
        pkey->next = pv;
        if (pkey != pend)
            pv->next->prev = pv;
        else pend = pv;
        return pv;
    }
    return 0;
}
 
template<class T> bool List<T>::remove(T key)
{
    if (Node* pkey = find(key))
    {
        if (pkey == pbeg)
        {
            pbeg = pbeg->next;
            pbeg->prev = nullptr;
        }
        else if (pkey == pend)
        {
            pend = pend->prev;
            pend->next = nullptr;
        }
        else
        {
            pkey->prev->next = pkey->next;
            pkey->next->prev = pkey->prev;
        }
        delete pkey;
        return true;
    }
    return false;
}

class Number
{
    friend ostream& operator<<(ostream& out, const Number& otherNumber);
    friend istream& operator>>(istream& in, Number& otherNumber);
private:
    int multiCount = 20;
    int Num_;
    void devide();
    int* ap_; //Указатель на массив множителей
public:
    Number(); 
    Number(int N);
    Number(const Number& otherNumber);
    ~Number();
    void show();
    void add(Number const& otherNumber);
    void subtract(Number const& otherNumber);
    void multiply(Number const& otherNumber);
    int compare(Number const& otherNumber) const;
    void setnewvalue(int N);
    Number operator+(Number otherNumber);
    Number operator-(Number otherNumber);
    Number operator*(Number otherNumber);
    Number& operator=(Number& otherNumber);
    bool operator>(const Number& otherNumber) const;
    bool operator<(const Number& otherNumber) const;
    bool operator==(const Number& otherNumber) const;
    bool operator!=(const Number& otherNumber) const;
};

Number & operator = (const Number & other)
{
    Number temp(other);     // Вся работа выполняется здесь
    Swap(temp);             // Здесь исключений не может быть
    return *this;
}

Number & operator=(Number temp)
{
    Swap(temp);
    return *this;
}

class Class
{
    // ...
public:
    void Swap(Class &) noexcept;
};
 
 
class SomeClass
{
    int i;
    double d;
    Class c;
 
    void Swap(SomeClass & r) noexcept
    {
        int ti;
        double td;
 
        ti = i;
        i = r.i;
        r.i = ti;
 
        td = d;
        d = r.d;
        r.d = td;
 
        c.Swap(r.c);
    }
};

class T {
    int *arr;
    size_t sz;
public:
    //.......
 
    T& operator = (const T& ref) {
        if (this != &ref)
        {
            T(ref).swap(*this);
        }
        return *this;
    }
 
    //......
 
private:
    void swap(T & t)
    {
        std::swap(arr, t.arr);
        std::swap(sz, t.sz);
    }
};

T& operator = (T val) {
       
            swap(val);
       
        return *this;
    }