How do I make a copy constructor in C++ using linked lists?

Question

Here is the structure of the linked list:

struct Node
{
    char item;
    Node *next;
    Node(char Item, Node *Next = NULL);
};
Node *head;

I don't understand how to do this, I was told that this is the wrong way to do it

//copy constructor
Stack::Stack(const Stack& obj) {
    head = obj.head;
}

How do I make the correct copy constructor?

By writing the code, that copies the data stored in the class instance, you want to copy? — Algirdas Preidžius, Apr 25 '18 at 13:52
If your teacher has nothing constructive to say and just tells you "this is wrong" get another teacher. ASAP. — nvoigt, Apr 25 '18 at 13:55
@swagalistic Yes, I understood that? You asked: "_How do I make a copy constructor?_" I answered: "_By writing code that does such copy_". I fail to see what is unclear. — Algirdas Preidžius, Apr 25 '18 at 13:55
@swagalistic You don't know how to do what? Write code? If so: Learn from a [good C++ book](https://stackoverflow.com/questions/388242/the-definitive-c-book-guide-and-list). Your current "question" looks more like "write code for me" request. — Algirdas Preidžius, Apr 25 '18 at 13:58
Look if you aren't going to be helpful then don't comment. I've tried to look at many different resources and none of them make sense. — swagalistic, Apr 25 '18 at 13:59
Loop through your obj list copying each node. Don't just copy the pointers create new nodes and copy the data. — drescherjm, Apr 25 '18 at 14:06
Aside: If your teacher is telling you `new` and `delete` are required, get another teacher ASAP — Caleth, Apr 25 '18 at 14:28

score 1 · Answer 1 · answered Apr 25 '18 at 14:16

You need to create a new list with the same structure and the same items, but not the same nodes, as obj.head.

This is very convenient to do recursively:

Node* copy_list(const Node* original)
{
    if (original == nullptr)
    {
        return nullptr;
    }
    Node* tail_copy = copy_list(original->next);
    return new Node(original->item, tail_copy);
}

or even

Node* copy_list(const Node* n)
{
    return n == nullptr ? nullptr : new Node(n->item, copy_list(n->next));
}

or you can do it iteratively, which gets a bit more cumbersome:

Node* copy_list(const Node* n)
{
    Node* head = nullptr;
    Node* current = nullptr;
    while (n != nullptr)
    {
        Node* new_node = new Node(n->item);
        if (head == nullptr)
        {
            head = new_node;
        }
        else
        {
            current->next = new_node;
        }
        current = new_node;
        n = n->next;
    }
    return head;
}

and then

Stack::Stack(const Stack& obj)
  : head(copy_list(obj.head)) 
{
}

I'd swap the order in the `?:` to `return n ? new Node(n->item, copy_list(n->next)) : nullptr;` — Caleth, Apr 25 '18 at 14:24

Kaveh Vahedipour · Answer 2 · 2018-04-25T14:13:59.997

0

Regardless of the poor question, it's my helping day. So here you go. But if you don't come up with these solutions yourself, you're in a lot of trouble. This is the basics of c++.

struct Node {
    char item;
    Node *next;

    // Constructor
    Node(char Item, Node *Next = NULL) {};

    // Copy constructor 
    Node(Node const& other) {
        item = other.item;
        next = other.next;
    }
};

edited Apr 25 '18 at 14:13

answered Apr 25 '18 at 14:08

Kaveh Vahedipour

3,412
1
14
22

1

`*next` is UB, you are dereferencing an uninitialised pointer. You probably mean `next = new Node(*other.next)` – Caleth Apr 25 '18 at 14:11
Updated solution. You are completely right. It's a tree anyway, that he's building. – Kaveh Vahedipour Apr 25 '18 at 14:14
You now have the same problem as OP, i.e. a shallow copy. – molbdnilo Apr 25 '18 at 14:31
True. The situation cannot be salvaged from here. I don't see how you can take care of `next` if you are dealing with raw pointers to non members. – Kaveh Vahedipour Apr 25 '18 at 14:32

How do I make a copy constructor in C++ using linked lists?

2 Answers2