При возвращении объекта из функции данные затираются

// clab.h
struct SLabNode
{
    int data;
    SLabNode* next;
};
 
class CLab
{
    public:
        CLab();
        CLab(const CLab& obj);
        ~CLab();
    public:
        void add(const int data);
        void clear();
    public:
        // операторы
    private:
        SLabNode* deleteNode(SLabNode* obj);
    private:
        SLabNode* m_head, * m_tail;
};
 
// clab.cpp
CLab::CLab()
{
    this->m_head = this->m_tail = nullptr;
}
 
CLab::CLab(const CLab& obj) // конструктор копирования
{
    this->m_head = std::move(obj.m_head);
    this->m_tail = std::move(obj.m_tail);
}
 
CLab::~CLab()
{
    if (nullptr != this->m_head) clear();
}
 
void CLab::add(const int data)
{
    // выдление SLabNode и добавление в список с data
}
 
void CLab::clear()
{
    // очистка списка
}
 
SLabNode* CLab::deleteNode(SLabNode* list)
{
    // удаление list и возвращение следующего элемента после list
}
 
// main.cpp
// ...
int getMenuItem(const std::string& allowSymbols)
{
    int inputSymbol = 0;
    do { inputSymbol = _getch(); }
    while (std::string::npos == allowSymbols.find(inputSymbol));
    putchar(inputSymbol);
 
    return tolower(inputSymbol);
}
 
template<>
inline CLab getValue(std::istream& stream, const std::string& message)
{
    CLab buffer;
    bool isContinue = true;
 
    while (true == isContinue)
    {
        std::cout << "Хотите ввести элемент? (Y)es / (N)o"
            << std::endl << "> ";
 
        if ('y' == getMenuItem("YyNn"))
        {
            std::cout << std::endl;
            buffer.add(getValue<int>(std::cin, message));
        }
        else isContinue = false;
    }
 
    return buffer; // <- здесь вызываеся конструктор копирования, после чего деструктор, из-за чего данные затираются и возвращается белеберда
}
 
// ...
CList<CLab> obj; // список из целочисленных списков (элементы которого - целые числа)
obj.add(getValue<CLab>(std::cin, "..."));
// ...

class CLab
{
public:
    //...
    CLab(const CLab& obj): CLab()
    {
        auto ptr = obj.m_head;
        while (ptr)
        {
            add(ptr->data);
            ptr = ptr->next;
        }
    }
    CLab(CLab&& obj)
        :
        m_head(std::exchange(obj.m_head, nullptr)),
        m_tail(std::exchange(obj.m_tail, nullptr))
    {}
    //...
};

CLab& operator=(const CLab& obj);
CLab& operator=(CLab&& obj);

CLab& CLab::operator=(const CLab& obj)
{
    this->m_head = std::move(obj.m_head);
    this->m_tail = std::move(obj.m_tail);
    return *this;
}
 
CLab& CLab::operator=(CLab&& obj)
{
    this->m_head = std::move(obj.m_head);
    this->m_tail = std::move(obj.m_tail);
    return *this;
}

void CLab::clear()
{
    this->m_tail = nullptr; // сразу удаляем конец
 
    while (this->m_head) // пока список не пуст
    {
        if (this->m_head)
        {
            this->m_head = deleteNode(this->m_head);
        }
        else // иначе список пуст
        {
            delete this->m_head;
            this->m_head = nullptr;
        }
    }
 
SLabNode* CLab::deleteNode(SLabNode* list)
{
    SLabNode* tempList = list->next;
    delete list;
    list = nullptr;
    return tempList; // возвращаем следующий элемент
}
}

class CLab
{
public:
    //...
    CLab(const CLab& obj) : CLab()
    {
        auto ptr = obj.m_head;
        while (ptr)
        {
            add(ptr->data);
            ptr = ptr->next;
        }
    }
    CLab& operator=(const CLab& obj)
    {
        if (this != &obj)
        {
            *this = CLab(obj);
        }
        return *this;
    }
    CLab(CLab&& obj) noexcept
        :
        m_head(std::exchange(obj.m_head, nullptr)),
        m_tail(std::exchange(obj.m_tail, nullptr))
    {}
    CLab& operator=(CLab&& obj) noexcept
    {
        std::swap(m_head, obj.m_head);
        std::swap(m_tail, obj.m_tail);
        return *this;
    }
    //...