appending a linklist node that has a linklist as a member

[cire]

I was told that template copy constructors was a no no(not that I cant use one but its a bad practice to do so).

It isn't bad practice. If you wish to support value/copy semantics and your class is managing its own memory, it is necessary or you end up destroying objects multiple times.

http://stackoverflow.com/questions/4172722/what-is-the-rule-of-three

I haven't checked your code to see if there is use of the copy assignment operator, but I wouldn't surprised if there was one. You'll probably need to supply that too.

Also I'm not sure where exactly I would use it. Should I copy the CD temp before I pass it to the CDList.insertNode()?

LinkList::insertNode takes it's argument by value. The compiler is already making a copy when you call it. It just happens to be using the inadequate defaulted copy constructor since you didn't supply your own.

[Khillz3000]

Also, Am I going about this the hard way. What I mean is there a simpler way of coding the addCD() function so that passing data and adding these nodes to the linked lists is less...cantankerous?

Thanks for the spelling correction. I hadn't even noticed. LOL!

[Khillz3000]

Been working on this all day and results are the same..crash!! I've been working on a copy constructor and I think that it works (only because I can step threw it in the debugger and I get no exceptions or errors) But I'm going to post it because I'm still having the same problem(the program trying to free already freed memory during clean up). I think the problem is the copy assignment operator. I have been looking around and I cant seem to find a good example of one for a linked list. Here is what I have so far:

//***Copy Constructor***
template <class T> 
LinkList<T>::LinkList( const LinkList &listObj )
{

	head = NULL;

	ListNode *nodePtr;

	nodePtr = listObj.head;

	while(nodePtr != NULL)
	{
		 appendNode(nodePtr->value1);
		
		 nodePtr = nodePtr->next;
	}

}

here is what I have so far for the assignment operator:

template <class T>
LinkList<T>::LinkList& operator =(const LinkList &listObj)
{

}

Is my copy constuctor correct? What do I need to put in the assignment operator to get it to work? Do I need copy constructors for my derived CD class and if so does that mean I need one for the base class Media?

Thanks for the help so far. I feel like I'm getting close to making this work!(I'm definitely learning alot!!)

[Khillz3000]

So the copy constructor dosen't work. I used a display function and it returned empty nodes. I need help with that too...Here is the display function for the LinkList class that I used. I added a call to it after the call to CDList.append() in main.

template <class T>
void LinkList<T>::displayList() const
{
	int count = 0;
	
	ListNode *nodePtr;

	nodePtr = head;

	while(nodePtr)
	{
		
		cout<<"Node index "<<count<<endl;
		cout<<nodePtr->value1<<endl;
	
		cout<<endl;

		count++;

		nodePtr = nodePtr->next;
	}
}

Guess I'm further off track than I thought.

[Khillz3000]

So do I need a copy constructor for my other classes to get this to work? If so how do I write a copy constructor for a derived class?

[cire]

Maybe you should start out with a simpler test in main:

 // Note: search-and-replaced some method and variable names so they were easier
 // for me to read, or just plain fit better: example -> appendNode: the 
 // client code doesn't need to know anything about nodes, so a better name
 // is just append.

#include <iostream>

template <class T>
class LinkList
{
private:

    struct ListNode
    {
        T value1;
        struct ListNode *next;
    };

    ListNode *head;   // List head pointer

    void destroy(); // utility function

public:
    //***Constructor***
    LinkList();
    LinkList(const LinkList&);

    //***Destructor***
    ~LinkList();

    LinkList& operator=(LinkList);

    //***LinkList Operations***
    void append(T);
    // removed insert since it's invariants are violated by append.
    void display(std::ostream& stream) const;
};

template <class T>
void LinkList<T>::display(std::ostream& os) const
{
    unsigned index = 0;

    ListNode* current = head;

    while (current)
    {
        os << index++ << ": " << current->value1 << '\n';
        current = current->next;
    }
}

//Implimentation for LinkList
template <class T>
void LinkList<T>::destroy()
{
    ListNode* current = head;

    while (current)
    {
        ListNode* next = current->next;
        delete current;
        current = next;
    }

    head = nullptr;
}

//***Constructor***
template <class T>
LinkList<T>::LinkList() : head(nullptr)
{
}

template <class T>
LinkList<T>::LinkList(const LinkList<T>& list) : head(nullptr)
{
    ListNode* current = list.head;

    while (current)
    {
        append(current->value1);
        current = current->next;
    }
}

template <class T>
LinkList<T>& LinkList<T>::operator=(LinkList list)
{
    destroy();
    head = list.head;
    list.head = nullptr;

    return *this;
}


//***Destructor***
template <class T>
LinkList<T>::~LinkList()
{
    destroy();
}


//***LinkList Operations***
template <class T>
void LinkList<T>::append(T val1)
{
    ListNode* n = new ListNode;
    n->value1 = val1;
    n->next = nullptr;

    if (head == nullptr)
        head = n;
    else
    {
        ListNode* current = head;

        while (current->next)
            current = current->next;

        current->next = n;
    }
}

int main()
{
    LinkList<int> a;
    a.append(3);
    a.append(2);
    a.append(1);
    a.display(std::cout);
    std::cout << '\n';

    LinkList<int> b(a);      // copy constructor
    b.display(std::cout);
    std::cout << '\n';

    LinkList<int> c;
    c = a;                   // copy assignment
    c.display(std::cout);
    std::cout << '\n';
}

http://ideone.com/VLZuf6

So do I need a copy constructor for my other classes to get this to work?

From a brief inspection of your code, it appears that the defaulted versions should work for your other classes, provided LinkList is implemented correctly. I would like to emphasize, though, that the inspection was not thorough.