accessing protected stuff

This is a general outline of my code. I am wondering why I have trouble accessing the protected members as such. Please let me know if what I have written is not enough info:

Code:

---


struct node
{
  node* child
  //...
}

struct node2
{
    node2* sibling
    //...
}

class one
{
    public:
        void a();
    protected:
        node* current;
};

class two : public one
{
    public:
        void b()
    private:
        node2* current2;
};

.
.
.

void two::b()
{
    //the linked list is NULL for functions in class two but in class one it is complete and works as expected.
    if(current->child != NULL) // never  proceeds through the if statement when I want it too...
    {
          //stuff
          a();
      }
    else
      {
          return;
      }
}

---

? You don't have a variable named node in class two. Even if you meant current2, that doesn't have a link field, just a field (confusingly) named current2.

tabstop: what I am trying to do is have access to the node in class one...

You don't have a variable named node in class one either.

sorry, I fixed it... Do you know what I am trying to do now? sorry about that

So what I am trying to do is not only have access to the protected stuff in class one but have all the values remain intact when using them from class two.

Well, every object of class two has its own current; it doesn't share one with some particular instance of class one.

How can I allow class two to share current with class one?

Well, but that doesn't really make any sense. Every object of class one has its own current too. If I did this:

Code:

---

one a, b, c, d;
two e, f, g, h;

---

I'd have eight different currents running around (I'd have a.current, and b.current, and ..., and h.current). What sense does it make to talk about sharing?

The second class builds a linked list that depends on how the first class created its own linked list. I do not want the second class to view it as NULL...

Why are you using a variable of class one at all, then? Just use a variable of class two the whole time. (There may be slicing issues, I suppose, but you can always pass by pointer if you have to.) Or if for some reason you want e to see a's linked list, then set e.current=a.current and be done with it. (Edit: of course, then any change made in e will be seen in a and vice versa.)

The linked lists have different designs. But are you saying move current from class one into class two? Then the functions from class one do not have access to it...

You don't need to move current from class one to class two -- it's already there. I'm guessing, based solely on what you seem to want from how I read your posts, that you should not have any variables of type one at all. You get a variable of type two; when you need the first kind of linked list you use current, when you need the second kind of linked list you use current2, and that's it.

I see what your saying (I think)... For example, class one has a function called a() that creates the first linked list, I just create an object from class two (call it e) and call e.a() .... then e.b() (b is a function of class two) will have the first linked list values intact...

right?

That's right.

Thanks tabstop! ... why was I not doing that in the first place?