Clueless to this C++ programming and need all the help i can get!!!!

[odlaw]

I am trying to do a C++ program but have no idea what i am doing HELP HELP HELP!!!

Instructions

On your textbook page 92, Figure 3.10 shows code for a generic doubly linked list. However, our textbook does not show all the DoublyLinkedList member functions. So, we should define all the missing member functions. Textbook shows two member functions – addToDLLTail( ) and deleteFromDLLTail( ). The missing member functions are addToDLLHead( ), deleteFromDLLHead( ), and deleteDLLNode( ).

To complete this job, I will take deleteDLLNode( ), and you will complete addToDLLHead( ) and deleteFromDLLHead( ). To make your life a little easier, I add a HW6-template.CPP, which has all the code already written except ones for addToDLLHead and deleteFromDLLHead. Download this file and fill out the code for both member functions. This is a generic class, so study the existing code carefully how template <class T> is handled.

- Note that DLLNode now has two pointers - *next and *prev. So, when you write a code, you must consider values of both pointers.

and here is the program from the book.

#ifndef DOUBLY_LINKED_LIST
#define DOUBLY_LINKED_LIST
template<class T>
class DLLNode {
public:
    DLLNode() {
        next = prev = 0;
    }
    DLLNode(const T& el, DLLNode *n = 0, DLLNode *p = 0) {
        info = el; next = n; prev = p;
    }
    T info;
    DLLNode *next, *prev;
};
template<class T>
class DoublyLinkedList {
public:
    DoublyLinkedList() {
        head = tail = 0;
    }
    void addToDLLTail(const T&);
    T deleteFromDLLTail();
    . . . . . . . . . . . . .
protected:
    DLLNode<T> *head, *tail;
};
template<class T>
void DoublyLinkedList<T>::addToDLLTail(const T& el) {
    if (tail != 0) {
         tail = new DLLNode<T>(el,0,tail);
         tail->prev->next = tail;
    }
    else head = tail = new DLLNode<T>(el);
}
template<class T>
T DoublyLinkedList<T>::deleteFromDLLTail() {
    T el = tail->info;
    if (head == tail) { // if only one node in the list;
         delete head;
         head = tail = 0;
    }
    else {              // if more than one node in the list;
         tail = tail->prev;
         delete tail->next;
         tail->next = 0;
    }
    return el;
}
. . . . . . . . . . . . .
#endif

How do i do all of that from the instructions please help i feel so stupid i do not know what im doing!!!!! Feel stupid!!!

[weaknessforcats]

Watch this video first: http://www.youtube.com/watch?v=9bX9WaIVyAg

This will explain the concept.

I assume you are all right with templates and it's just the linked list concept that is confusing.

[odlaw]

@weaknessforcats
thanks for the link, and help i appreciate it. i just feel out of my league with this stuff. what is confusing me i think is the addToDLLHead and deleteFromDLLHead code i still do not fully understand how to do it or what goes in these areas.

[weaknessforcats]

When you delete from the head of a linked list, the second node becomes the first node. So all you do is go to the first node and take the address inside the next pointer of that note and make it the first node in DoublyLinkedLIst.

You now have removed the original first node from the list. Hopefully you have saved the original first pointer in DoublyLinkedList so you can delete the pointer.

To delete from the tail you take the prev pointer in the tail and go the prev node. You make the next pointer in the prev node zero. Then you go to DoublyLinkedList and set the tail pointer to the address that was in the prev node of the original tail. You can now delete the original tail node.

I usually see deleting from the head, tail, or middle of a list all done by the same DoublyLinkedList member function. This function takes a node pointer as an argument and it tests the prev pointer of the node to be deleted and if it is zero, then there is no previous node making this a delete from the head. Likewise, a zero in the next pointer makes thie is delete from tail. Otherwise, it is a delete from the middle.

The DoublyLinkedList delete would call a Node member function to work out the prev/next values since DoublyLinkedList cannot see these private members of Node.

Done correctly, there will be only 5 lines of code in the entire program that will use the next/prev variables and these lines will be in a private Node member function that is called only by other Node member functions that need to adjust these values.

[odlaw]

thanks again for responding you make it sound simple. but i still just cant figure it all out. i wish i had never started this class its too late to drop and if i get a failing grade im in for it. im still probably going to flunk cause i just dont know where or what to do or begin and keep hitting myself for ever starting this.

[weaknessforcats]

Probably you understand more than you think. Just keep at it. A linked list is a fundamental concept that is used in all sorts of places where you least expect it.

The first time you take one of these C++ courses your retention might only be 10%. However, the next time you encounter these concepts your retention might increase to 20%. Eventually, it all makes sense. I used to tell my beginning students that learning C++ was like making Chinese lacquered furniture: 45 applications of lacquer later, you were done.

You sound exactly like me when I started in 1990.

[odlaw]

i thank you again for everything you have done to help me. this class will be over soon and i wont have to worry about it any more. it has been getting progressively worse and its only 5 weeks they are trying to push so much into that 5 weeks. online learning is a good thing, but when it comes to things like this i think they need to try to stretch it out for people who just cant get the hang of it. if you know what i mean. IF i pass it will be by the skin of my teeth.