Шаблонный класс двусвязного списка и rvalue ссылки

#pragma once
 
#include <ostream>
#include <list>
 
/* Doubly linked list node class */
 
template <typename T>
class   List_node
{
private:
    T           *data;
    List_node   *prev_ptr;
    List_node   *next_ptr;
 
template <typename U> friend class List;
};
 
/* Doubly linked list class */
 
template <typename T> 
class   List
{
private:
    List_node<T>    *head;
 
    List_node<T>    *__create_node(T&& value);
 
public:
    List();
    ~List();
 
    size_t          size();
    bool            empty();
    void            clear();
    void            print(std::ostream& outstream);
    void            push_back(T&& value);
};
 
template <typename T>
List<T>::List()
{
    head = nullptr;
}
 
template <typename T>
List<T>::~List()
{
    List_node<T>    *temp_ptr;
 
    if (head != nullptr)
    {
        while (head->next_ptr != nullptr)
        {
            temp_ptr = head;
            head = head->next_ptr;
            delete temp_ptr;
        }
    }
}
 
template <typename T>
List_node<T>    *List<T>::__create_node(T&& value)
{
    List_node<T>    *new_node;
    
    new_node = new List_node<T>;
    if (new_node)
    {
        new_node->data = &value;
        new_node->next_ptr = nullptr;
        new_node->prev_ptr = nullptr;
    }
    return (new_node);
}
 
template <typename T>
bool    List<T>::empty()
{
    return (head == nullptr);
}
 
template <typename T>
size_t  List<T>::size()
{
    List_node<T>    *temp_ptr;
    size_t          size = 0;
 
    if (head == nullptr)
        return (0);
    temp_ptr = head;
    while (temp_ptr != nullptr)
        size++;
    return (size);
}
 
template <typename T>
void    List<T>::clear()
{
    List_node<T>    *temp_ptr;
 
    if (head != nullptr)
    {
        while (head->next_ptr != nullptr)
        {
            temp_ptr = head;
            head = head->next_ptr;
            delete temp_ptr;
        }
    }
    head = nullptr;
}
 
template <typename T>
void    List<T>::print(std::ostream& outstream)
 
{
    List_node<T>    *temp_ptr;
 
    if (!head)
        return ;
    temp_ptr = head;
    while (temp_ptr->next_ptr != nullptr)
    {
        outstream << *(temp_ptr->data) << " ";
        temp_ptr = temp_ptr->next_ptr;
    }
    outstream << "\n";
}
 
template <typename T>
void    List<T>::push_back(T&& value)
{
    List_node<T>    *new_node;
    List_node<T>    *curr_node;
    List_node<T>    *prev_node;
 
    new_node = __create_node(value);
    if (new_node != nullptr)
    {
        if (!head)
        {
            head = new_node;
            return ;
        }
        else
        {
            curr_node = head;
            while (curr_node->next_ptr != nullptr)
            {
                prev_node = curr_node;
                curr_node = curr_node->next_ptr;
            }
            curr_node->next_ptr = new_node;
            if (curr_node != head)
                curr_node->prev_ptr = prev_node;
        }
    }
}

#include <iostream>
#include "./headers/doubly_linked_list.hpp"
 
int main()
{
    List<int>   new_list;
 
    new_list.push_back(12);
    new_list.push_back(14);
    new_list.push_back(1552);
 
    new_list.print(std::cout);
 
    return (0);
}

new_node = __create_node(static_cast<T&&>(value));

template <typename T> class DoubleLinkedListNode
    {
        template<typename T> friend class DoubleLinkedList;
        
 
    public:
        DoubleLinkedListNode(T otherValue = T(), DoubleLinkedListNode* otherpPrev = nullptr, DoubleLinkedListNode* otherpNext = nullptr);
 
        T& GetValue()
        {
            return this->m_Value;
        }
 
    private:
 
        DoubleLinkedListNode* pPrev;
        DoubleLinkedListNode* pNext;
        T m_Value;
    };
 
    template<typename T>
    inline DoubleLinkedListNode<T>::DoubleLinkedListNode(T otherValue, DoubleLinkedListNode* otherpPrev, DoubleLinkedListNode* otherpNext)
    {
        this->m_Value = otherValue;
        this->pPrev = otherpPrev;
        this->pNext = otherpNext;
    }

template <typename T> class DoubleLinkedList
    {
    public:
        DoubleLinkedList()
    {
        this->m_pHead = nullptr;
        this->m_pTail = nullptr;
        this->m_iSize = 0;
    }
        class iterator
        {
        public:
 
            iterator()
            {
                this->m_pCurrent = nullptr;
            }
 
            
 
        private:
 
            DoubleLinkedListNode<T>* m_pCurrent;
        };
 
    private:
 
        DoubleLinkedListNode<T>* m_pHead;
        DoubleLinkedListNode<T>* m_pTail;
        int m_iSize;
        }