c++ - instruct std::list.push_back() to make use of the heap allocated memory address

Question

As far as I know std::list stores it's elements internally in a doubly linked list format which means heap memory is allocated. Suppose if I already have a variable that is heap allocated using new, can I instruct std ::list push_back() function to make use of this memory in it's internal doubly linked list instead of freshly allocating new memory and then copy the data into that new memory. This is a sample code:

#include <iostream>
#include <list>

struct St {
    int a;
    int b;
};

int main()
{
    std::list<St> St_list;
    St *st = new St;
    st->a = 1;
    st->b = 2;

    St_list.push_back(*st); // can i instruct St_list to use the memory address of st
    
    std::cout << st << std::endl;
    std::cout << &St_list.back() << std::endl;
    
    return 0;
}

Answer 1

The simplest answer is NO, the memory cannot be re-used.

To explain a little - the internal node class of std::list does not keep the "pointer" to value - but value itself. This node is defined more or less like this:

template <class T>
struct List_Node {
   T value; 
   List_Node* prev;
   List_Node* next;
}; 

So there is no possibility to "re-use" allocated memory.

But - nodes can be transferred between std::list<T> objects with splice, thus we can avoid reallocation.

std::list<St> st{{1,2}};

std::list<St> St_list;
St_list.splice(St_list.end(), st);
// now st is empty, St{1,2} is in St_list - no "reallocation" happened