shared pointer swap method identity change - c++

Question

Background:
I donot know what caused me to experiment with this, but I am trying to test a containerised linked list which internally uses smartpointers.
Here is the repl link:
https://repl.it/#BasavarajNagar/GoodnaturedGlisteningSection-1
#include <memory>
using namespace std;
template<typename T>
class linkedlist {
private:
class node {
public:
T data;
shared_ptr<node> next;
node(T data) {
this->data = data;
}
};
// non const unique ptr
shared_ptr<node> head;
public:
void add(T data) {
cout<< "adding " << endl;// + data << endl;
if (head == nullptr) {
head = shared_ptr<node>(new node(data));
return;
}
shared_ptr<node> cursor;
cursor.swap(head);
// this works well
while (cursor != nullptr) {
cout << cursor->data << endl;
cursor = cursor->next;
}
cout << data << endl;
// this is the problematic assignment
cursor = shared_ptr<node>(new node(data));
}
void trace() {
shared_ptr<node> cursor;
cursor.swap(head);
cout << "trace" << endl;
while (cursor != nullptr) {
cout << cursor->data << endl;
cursor = cursor->next;
}
}
};
int main() {
std::cout << "Hello World!\n";
linkedlist<int> ll;
ll.add(22);
ll.add(45);
ll.add(63);
ll.trace();
}
The trace method always points to last element, the head is lost after swap during add method.
Note:
I know this is not production quality code, but to understand internals/quirks of smartpointers. So, pls avoid code quality comments.

Answer 1

You badly misunderstand shared pointers. https://en.cppreference.com/w/cpp/memory/shared_ptr/shared_ptr
The trace info you need most is node::node and node::~node. Tracking when actual nodes get created and destroyed will help you. You also must understand scope.
A quick critique of your "add" function (fixes left to you, beyond the scope of the question and detrimental for me to post too much):
It creates a single item list correctly. However, if you try to add again, you move head to a temporary object, setting head to nullptr. You then loop cursor through the list, destructing any nodes that might have existed, until there are no more. The fact that you have just assigned nullptr to cursor is not a problem, because you immediately toss whatever value it might have had as you then create a new list with a single item, held by cursor instead of head. You then go out of scope, destructing cursor, and therefore also destructing that new item that you just added to cursor.
But the biggest problem is your trace function, which you are using to understand your list, but it's not doing anything remotely like what you want. This is the biggest problem, because you think you understand what is going on based on bad information. If trace lies to you, then you can't get anywhere using it to understand add.
Here is a trace function which will correctly print the current contents of your list, without destroying it:
void trace() {
cout << "trace: ";
shared_ptr<node> cursor = head; // SHARE, do not lose head, read the docs
while (cursor.get()) {
cout << cursor->data << ", ";
cursor = cursor->next;
}
cout << endl;
}
I would suggest calling the trace function twice in a row. If it's not destroying the list as it prints it, then the second call should have the same output as the first. To fix add, you need to simplify it. Just follow what you should do on a regular node pointer. Your big problem was using "swap" to place your actual data under the sole control of a temporary object, which will quickly DO ITS JOB, which is destroy all your data.