C++: Copy constructor is deleting nodes in original object - c++

Question

I have implemented a singly linked list using a template class and attempted to create a working copy constructor. When the copy constructor is called, it accurately duplicates the list. However, it deletes nodes from the original.
Here is the class implementation, the constructors, and the destructors:
template<class L>
class LinkedList
{
public:
LinkedList();
LinkedList(const LinkedList<L> &og);
~LinkedList();
Node<L>* AddToEnd(L object);
Node<L>* AddToMiddle(L object);
Node<L>* DeleteNode(L deleteItem);
Node<L>* ReverseList();
void Display();
int Size();
private:
Node<L>* head;
Node<L>* tail;
int size;
};
template<class L>
LinkedList<L>::LinkedList()
{
head = NULL;
tail = NULL;
size = 0;
}
template<class L>
LinkedList<L>::LinkedList(const LinkedList<L> &og)
{
cout << "\nCopy constructor has been called.\n\n";
head = new Node<L>;
*head = *og.head;
tail = new Node<L>;
*tail = *og.tail;
size = og.size;
}
template<class L>
LinkedList<L>::~LinkedList()
{
delete head;
delete tail;
}
And main.cpp:
#include "Header.h"
int main()
{
int int1 = 1;
int int2 = 2;
int int3 = 3;
int int4 = 4;
int int5 = 5;
cout << "Creating the first integer list..." << endl;
LinkedList<int> intList1;
intList1.AddToEnd(int1);
intList1.AddToEnd(int2);
intList1.AddToEnd(int3);
intList1.AddToEnd(int4);
intList1.AddToEnd(int5);
intList1.Display();
cout << endl << "Cloning and reversing..." << endl;
LinkedList<int> intList2(intList1);
intList2.ReverseList();
cout << "Original list: " << endl;
intList1.Display();
cout << "Reversed list: " << endl;
intList2.Display();
return 0;
}
The output looks like this:
Creating the first integer list...
1
2
3
4
5
Cloning and reversing...
Copy constructor has been called.
Original list:
1
2
1
Reversed list:
5
4
3
2
1

Answer 1

Your copy constructor is totally wrong. You should iterate through the linked list and copy each element of that list. Also your tail should point to the last element of the list.
So the code would be something like this.
template<class L>
LinkedList<L>::LinkedList(const LinkedList<L> &og)
{
cout << "\nCopy constructor has been called.\n\n";
head = new Node<L>;
*head = *og.head;
Node *p = og.head->next;
Node *i = head;
while (p != NULL) {
i->next = new Node<L>;
*(i->next) = *p;
p = p->next;
i = i->next;
}
tail = i;
size = og.size;
}

Answer 2

Your copy constructor definition needs to do more than what it is doing now.
Right now what you are doing is just duplicating the head and tail pointers, which is not enough. This way, your cloned list is essentially the same as first list. What you need to do is duplicate every node, something like:
for (Node<L>* n = og.first(); n != NULL ; n = n->next()) {
this->AddToEnd(n->value());
}
Additionally, your destructor is not cleaning up properly. You probably want to delete all the nodes you may have added.

Answer 3

Have your copy-constructor iterate through the nodes in og's list and append them to your list:
template<class L>
LinkedList<L>::LinkedList(const LinkedList<L> &og)
: head(NULL)
, tail(NULL)
{
for (Node* p(og.head); p != NULL; p = p->next)
{
AddToEnd(p->value);
}
}
Where value is the datum that a Node contains.
Your destructor is also incorrect. It should iterate through the list and delete the nodes one by one. Deleting only head and tail will cause the entire list to be lost if there are more elements:
template<class L>
LinkedList<L>::~LinkedList()
{
while (head)
{
Node<L>* temp(head);
head = head->next;
delete temp;
}
}