C++ Linked List question

lowpro2k3 · 06-15-2005, 10:10 PM

I'm building a Linked List at the moment, consisting of a "Node" class and a "List" class. I'm wondering if this is an appropriate place for using a "friendship" relationship - my teacher seemed to frown on using "friends" in C++ unless we need to. My logic: the List class should be able to manipulate the Node class's pointers without function calls for every manipulation.

I'm using this kind of implementation right now, and it is working. Yay or nay?

Code:

class Node {
    friend class List;
...

};


...

class List {

...

};

AdaHacker · 06-15-2005, 10:37 PM

Quote:

Originally posted by lowpro2k3
My logic: the List class should be able to manipulate the Node class's pointers without function calls for every manipulation.

Why? The rule of thumb is that you shouldn't give more access than you really need to. Do you have some good reason for ignoring this rule, or did you just arbitrarily decide that direct access is good and functions are bad?

Your teacher is right - "friend" is one of those things that you probably shouldn't be using unless you really need it, and in this case, you definitely don't need it. Sure, the code works, but there's lots of code out there that's chock full of gotos and global variables that also works. Trust me, it's easier to learn good programming practices the first time than to try to break bad habits later.

lowpro2k3 · 06-15-2005, 11:00 PM

Didnt mean to post here, wrong thread (dont ask!)

Looking over my code I see where I could lose the friendship relationship. I'll wait for a few more opinions, IMO the stack overhead incurred is not worth pleasing all the OO fanatics. I do believe in it to a high extent (this -is- the first time I'm going out of my way to use it instead of get/set methods), but if I'm reading in massive files I would like to run benchmarks on both (friends vs. no friends) and see which is faster.

Maybe my other teacher is right - I try to hard to be a "hotshot"

Hivemind · 06-16-2005, 10:15 AM

For nodes I would use a private (or maybe protected) nested struct. Nodes shouldn't be visible to the user of your list class but only used internally by your class and thus a struct is fine. Remember that a struct in C++ works almost like a class, the only difference is that the default access label is public for structs and private for classes. This means a struct can have constructors and all other useful things classes have.
Say you're making a doubly-linked list class storing ints, the Node-struct could be (but usually templated of course):

Code:

struct Node
{
   Node() : m_next(NULL), m_previous(NULL), m_data(0) {}

   Node(int data) : m_next(NULL), m_previous(NULL), m_data(data) {}
   
   Node *m_next;
   Node *m_previous;
   int m_data;
};

As I see it, you're not violating any "OO rules" with a struct like this since it's a type that's private to the class. For types used directly by end-users, I rarely use structs, though.