Thread: Data protection question

If I have a PRIVATE Node (struct) as part of my List class. I also have a PUBLIC Iterator class as part of my List class.

I have the following dilemma:

Iterator looks like this:

Code:

class Iterator{
private:
Node* curr;
public:
Iterator(Node* c = 0) : curr(c) {}

/* etc/operators */

Node* get_curr() const ( return curr; }

I wrote this function (get_curr()) so in my implementation I could do the following:

Code:

/* iterate the list to some specific position */
Node* temp = i.get_curr();

where "i" is an iterator object.


Outside of my class, Node is private, but a user CAN use the get_curr() function (though they can never return a Node outside the class.)

Is THIS BAD?

BTW, this is my value look-up method:

Code:

const T& operator* const { return curr->data; };

To me it sounds like you're doing it a little backward. The point of an iterator as far as I can see is simply to provide access to parts of the data structure, instread of resorting to raw pointers or some other hack.

You were sort of on the right track with get_curr(). Since you're building a list out of nodes, doesn't it make sense to have the iterators dereference operator return some reference to a node, and let node manage it's own data and access priveleges?

well this is really the only opportunity for someone to even mention a node:

Code:

List<int>::Iterator iter2 = someList.at(iter1.get_curr());

As you can see, the only thing they CAN DO is use it to create another iterator.


THIS can NEVER happen:

Code:

Node* someNode = someIter.get_curr();

the header file is kinda long, so maybe i could PM to someone if they're interested and they could critique it, telling me what's good and what's not so good, and what i could do differently that might make it better?

anyone interested?