Chapter 14: Point and Stare at Objects 195
Linking Up with Linked Lists
The second most common structure after the array is called a list. Lists come in different sizes and types; however, the most common one is the linked list. In the linked list, each object points to the next member in a sort of chain that extends through memory. The program can simply point the last element in the list to an object to add it to the list. This means that the user doesn’t have to declare the size of the linked list at the beginning of the program — you can cause the linked list to grow (and shrink) as necessary by adding (and removing) objects.
The cost of such flexibility is speed of access. You can’t just reach in and grab the tenth element, for example, like you would in the case of an array. Now, you have to start at the beginning of the list and link ten times from one object to the next.
A linked list has one other feature besides its run-time expandability (that’s good) and its difficulty in accessing an object at random (that’s bad) — a linked list makes significant use of pointers. This makes linked lists a great tool for giving you experience in manipulating pointer variables.
Not every class can be used to create a linked list. You declare a linkable class as follows:
class LinkableClass
{
public:
LinkableClass* pNext;
// other members of the class
};
The key is using the pNext pointer to an object of class LinkableClass. At first blush, this seems odd indeed — a class contains a pointer to itself? Actually, this says that the class Linkable contains a pointer to another object also of class Linkable.
The pNext pointer is similar to the appendage used to form a chain of chil dren crossing the street. The list of children consists of a number of objects, all of type child. Each child holds onto another child.
The head pointer is simply a pointer of type LinkableClass*: To keep tor turing the child chain analogy, the teacher points to an object of class child. (It’s interesting to note that the teacher is not a child — the head pointer is not of type LinkableClass*.)
LinkableClass* pHead = (LinkableClass*)0;
196 Part III: Introduction to Classes
Always initialize any pointer to 0. Zero, generally known as null when used in the context of pointers, is universally known as the non-pointer. In any case, referring to address 0 always causes the program to halt immediately. The cast from the int 0 to LinkableClass* is not necessary. C++ understands 0 to be of all types, sort of the “universal pointer.” However, I find the use of explicit casts a good practice.
The pointer to the first member in a linked list is called the head pointer. The pointer to the last member, if there is one, is called the tail pointer — hence, the name pHead in this example. (I also like the name because it sounds like you’re insulting someone by calling them a “pea head.” Don’t even get me started on a pointer to a pHead.)
To see how linked lists work in practice, consider the following function, which adds the argument passed it to the beginning of a list:
void addHead(LinkableClass* pLC)
{
pLC->pNext = pHead; pHead = pLC;
}
Here, the pNext pointer of the object is set to point to the first member of the list. This is akin to grabbing the hand of the first kid in the chain. The second line points the head pointer to the object, sort of like having the teacher let go of the kid we’re holding onto and grabbing us. That makes us the first kid in the chain.
Performing other operations on a linked list
Adding an object to the head of a list is the simplest operation on a linked list. Moving through the elements in a list gives you a better idea about how a linked list works:
// navigate through a linked list LinkableClass* pL = pHead; while(pL)
{
//perform some operation here
//get the next entry
pL = pL->pNext;
}
The program initializes the pL pointer to the first object of a list of LinkableClass objects through the pointer pHead. (Grab the first kid’s hand.)
Chapter 14: Point and Stare at Objects 197
The program then enters the while loop. If the pL pointer is not null, it points to some LinkableClass object. Control enters the loop, where the program can then perform whatever operations it wants on the object pointed at by pL.
The assignment pL = pL->pNext “moves” the pL pointer over to the next kid in the list of objects. The program checks to see if pL is null, meaning that we’ve exhausted the list . . . I mean run out of kids, not exhausted all the kids in the list.
Hooking up with a LinkedListData program
The LinkedListData program shown here implements a linked list of objects containing a person’s name. The program could easily contain whatever other data you might like, such as social security number, grade point aver age, height, weight, and bank account balance. I’ve limited the information to just a name to keep the program as simple as possible.
//LinkedListData - store data in a linked list of objects #include <cstdio>
#include <cstdlib> #include <iostream> #include <string.h> using namespace std;
//NameDataSet - stores a person’s name (these objects
// |
could easily store any other information |
// |
desired). |
class NameDataSet |
|
{
public:
char szName[128];
// the link to the next entry in the list NameDataSet* pNext;
};
// the pointer to the first entry in the list NameDataSet* pHead = 0;
// add - add a new member to the linked list void add(NameDataSet* pNDS)
{
// point the current entry to the beginning of // the list...
pNDS->pNext = pHead;
// point the head pointer to the current entry pHead = pNDS;
198 Part III: Introduction to Classes
}
//getData - read a name and social security
//number; return null if no more to
//read
NameDataSet* getData()
{
//read the first name char nameBuffer[128]; cout << “\nEnter name:”; cin >> nameBuffer;
//if the name entered is ‘exit’...
if ((stricmp(nameBuffer, “exit”) == 0))
{
// ...return a null to terminate input return 0;
}
//get a new entry to fill NameDataSet* pNDS = new NameDataSet;
//fill in the name and zero the link pointer strncpy(pNDS->szName, nameBuffer, 128); pNDS->szName[127] = ‘\0’; // ensure string is terminated pNDS->pNext = 0;
//return the address of the object created
return pNDS;
}
int main(int nNumberofArgs, char* pszArgs[])
{
cout << “Read names of people\n”
<<“Enter ‘exit’ for first name to exit\n”;
//create (another) NameDataSet object NameDataSet* pNDS;
while (pNDS = getData())
{
//add it onto the end of the list of
//NameDataSet objects
add(pNDS);
}
//to display the objects, iterate through the
//list (stop when the next address is NULL) cout << “Entries:\n”;
pNDS = pHead; while(pNDS)
{
//display current entry
cout << pNDS->szName << “\n”;
Chapter 14: Point and Stare at Objects 199
// get the next entry pNDS = pNDS->pNext;
}
//wait until user is ready before terminating program
//to allow the user to see the program results system(“PAUSE”);
return 0;
}
Although somewhat lengthy, the LinkedListData program is simple if you take it in parts. The NameDataSet structure has room for a person’s name and a link to the next NameDataSet object in a linked list. I mentioned earlier that this class would have other members in a real-world application.
The main() function starts looping, calling getData() on each iteration to fetch another NameDataSet entry from the user. The program exits the loop if getData() returns a null, the “non-address,” for an address.
The getData() function prompts the user for a name and reads in whatever the user enters. The program just hopes that the number of characters is less than 128, since it makes no checks. If the string entered is equal to exit, the function returns a null to the caller, thereby exiting the while loop. The stricmp() compares two strings without regard to case. If the string entered is not exit, the program creates a new NameDataSet object, populates the name, and zeroes out the pNext pointer.
Never leave link pointers uninitialized. Use the old programmer’s wives’ tale: “When in doubt, zero it out.” (I mean “old tale,” not “tale of an old wife.”)
Finally, getData() returns the object’s address to main().
main() adds each object returned from getData() to the beginning of the linked list pointed at by the global variable pHead. Control exits the initial while loop when the getData() returns a null. main() then enters a second section that iterates through the completed list, displaying each object. The second while loop terminates when it reaches the last object, the object with a pNext pointer whose value is null.
The program outputs the names entered in the opposite order. This is because each new object is added to the beginning of the list. Alternatively, the program could have added each object to the end of the list — doing so just takes a little more code.