Writing Copy Constructor & Assignment Operator Methods

[incremental]

I'm just wondering how you would write an assignment operator and copy constructor methods. This has been a big sticking point for me. I know that when you do something like

 node * head = NULL;
// some form of making nodes that connect, blah blah blah.
node * temp = head;

You can't just assume that when you copy that you're getting everything. And by this, I mean you need to overload the assignment operator so that it will do a deep copy. I'm having trouble writing it. I think it would be easy to do it recursively. Pass in the head node, and check for NULL. If its not NULL, call the method again, until you hit NULL. Also making sure you copy when its not NULL. Any help?

[MrHutch]

Well the copy constructor or overloaded operator would do the same job here, really, so take your pick.

In either, you'll just need to pass in a node as a parameter, then assign each of the values of the node accordingly.

I'm not at a compiler or anything right now, but I guess the syntax would be something like this:

node::node(const node& n)
{
   this->data = n.data;
   this->other_data = n.other_data;
}

If you want to avoid copying a NULL node, just enclose the functionality above in a check:

node::node(const node& n)
{
   if( n != NULL)
   {
      this->data = n.data;
      this->other_data = n.other_data;
   }
}

Again, syntax might be off, but hopefully you get the gist.

[Cubbi]

making assumptions about the rest of your class (it would have helped if you posted it), sounds like you'r looking for something like:

template<typename T>
struct Node {
    Node* head;
    T data;
    Node(const T& data) : head(nullptr), data(data) {}
    Node(const Node& n) : head(n.head ? new Node(*n.head) : n.head), data(n.data) {}
    Node& operator=(Node n) { 
            std::swap(head, n.head); 
            std::swap(data, n.data); 
            return *this; 
    }
    ~Node() { delete head; }
};

but you may consider better pointers, too, such as std::unique_ptr

[incremental]

#include <iostream>
#include <string>
using namespace std;

#ifndef ORDEREDH
#define ORDEREDH

class node
{
public:

	double data;
	node * next;
	
	node() {next = NULL;}
	node( double value ) { data = value; next = NULL; }
	
};

class LinkedList
{
public:
	LinkedList() { head = NULL; }
	//~LinkedList();
	LinkedList( const LinkedList &other );
	LinkedList& operator=(const LinkedList & rhs);

	void Insert( double value );
	bool RemoveByVal( double value );
	bool RemoveByPos( int pos );
	void Print();
	bool Find( double value );

	// unused
	void Append( double value );
private:
	node * head;
};

#endif  

#include "ordered.h"

LinkedList::LinkedList( const LinkedList &other ) // does not work
{
	if(other.head == NULL)
		return;
	
}

LinkedList& LinkedList::operator=(const LinkedList & rhs) // does not work
{
	if(rhs.head == NULL)
		return *this;
	
	return *this;	
}

// missing the destructor

void
LinkedList::Append( double value )
{
	if( head == NULL )
	{
		head = new node( value );
		return;
	}
	node * current = head;
	while( current->next != NULL) 
	{
		current = current->next;
	}
	current->next = new node(value);
}

void
LinkedList::Insert( double value )
{
	node * temp = new node( value );

	// condition for empty list
	if( head == NULL )
	{
		node * temp = new node( value );
		temp->next = head;
		head = temp;
		return;
	}

	// condition to put the new item before the first item
	if(temp->data < head->data)
	{
		temp->next = head;
		head = temp;
		return;
	}
	//initial traversal to correct position in list
	node * current = head;
	while( (current->data < temp->data) && (current->next != NULL) )
	{
		current = current->next;
	}
	
	// changes to put new item in the list
	temp->next = current->next;
	current->next = temp;
	return;
}

void
LinkedList::Print()
{
	node * current = head;
	while( current != NULL )
	{
		cout << current->data << endl;
		current = current->next;
	}
	cout << endl;
}

bool 
LinkedList::Find( double value )
{
	node * current = head;
	int count = 1;
	while( current != NULL )
	{
		if( value == current->data )
		{
			cout << "Found at position " << count << endl;
			return true;
		}
		current = current->next;
		count++;
	}
	cout << "No such value, '" << value << "'" << endl;

	return false;
	
}

bool
LinkedList::RemoveByVal( double value )
{
	node * temp = NULL;
	// used if first element has value to be removed
	if(head->data == value)
	{
		temp = head->next;
		head = temp;
		cout << value << " was removed. " << endl;
		Print();
		return true;
	}

	//initial traversal to correct position in list
	node * current = head;

	while( (current->data != value) && (current->next != NULL) )
	{
		if(current->next->data != value)
		{
			current = current->next;
		}
		else
		{
			temp = current->next->next;
			current->next = temp;
			//delete temp;
			cout << value << " was removed. " << endl;
			Print();
			return true;
		}
	}	
	cout << value << " wasn't in the list. " << endl;
	return false;

}

bool
LinkedList::RemoveByPos( int pos )
{
	//initial traversal to correct position in list
	node *current = head;
	int ct = 1;
	while( (ct < pos - 1) && (current->next != NULL))
	{
		current = current->next;
	}
	return false;
} 

[Cubbi]

Yes, the usual copy and assignment work for you:

class node
{
public:
    double data;
    node * next;

    node() : next(NULL) {} // I don't think default ctor makes sense, actually
    node( double value ) : data(value), next(NULL) {}
    node( const node& n) : data(n.data),
                           next(n.next ?  new node(*n.next) : NULL)  {}
    node& operator=(node n) { 
            std::swap(next, n.next); 
            std::swap(data, n.data); 
            return *this; 
    }
    ~node() { delete next; }
};

(remember to #include <utility> or #include <algorithm> to get std::swap)

How did you write such a big program without completing the node class, though? Consider testing the components you write before combining them into a larger program.

[incremental]

I was told you shouldn't create a destructor in the node class because its not allocating memory. I was told that I should create a destructor for my linked list class instead.

[incremental]

Also I was referring to the copy, assignment, and destructor methods for my linked list class, not the node class.

[MrHutch]

The three amigos, write all or none: http://www.cs.umd.edu/class/spring2002/cmsc214/Projects/P1/copy-dest.html