Can nested class members access private members of nesting class?

Discussion in 'C++' started by CoolPint, Dec 13, 2003.

  1. CoolPint

    CoolPint Guest

    I read in books that nested class cannot access private members of
    nesting class and vice versa unless they are made friends. Somehow, my
    compiler is letting my nested class member functions access private
    members of nesting class.

    template <typename T>
    class Container {
    // NO friendship given to any other
    public:
    class ContainerIterator;
    // other members
    private:
    class Node;
    Node * header;
    Node * tailer;
    int counter;
    };

    Nested class Node has all of its members as public so that Container
    members can access them. And then I have the nested Class
    ContainerIterator, which have both public and private parts.

    template <typename T>
    class Container<T>::ContainerIterator {

    friend class List<T>; // so that List<T> can access private members of
    Iterator
    public:
    // public members
    private:
    List<T>::Node * dummyheader;
    List<T>::Node * ptr;
    ContainerIterator(const List<T> & l , List<T>::LNode * p);
    // private members
    };

    I forget to declare ContainerIterator class to be a friend of
    Container class, yet member functions of ContainerIterator can access
    private members of Container class! For example,
    ContainerIterator(const List<T> & l , List<T>::LNode * p)
    {
    dummyheader = l.header; // ! This works! but why?
    ptr = p;
    };

    So am I misinterpreting the books or is my compiler not following the
    standard? BTW, I am using g++ 3.2.3. I am quite confused to be honest
    and would appreciate any help very much. Thanks in advance.
    CoolPint, Dec 13, 2003
    #1
    1. Advertising

  2. CoolPint wrote:

    > I read in books that nested class cannot access private members of
    > nesting class and vice versa unless they are made friends. Somehow, my
    > compiler is letting my nested class member functions access private
    > members of nesting class.


    OK, we are saying about class *Container* with some private members.

    > template <typename T>
    > class Container {
    > // NO friendship given to any other
    > public:
    > class ContainerIterator;
    > // other members
    > private:
    > class Node;
    > Node * header;
    > Node * tailer;
    > int counter;
    > };
    >
    > Nested class Node has all of its members as public so that Container
    > members can access them. And then I have the nested Class
    > ContainerIterator, which have both public and private parts.


    OK, now we are saying about nested class ContainerIterator nested to class
    *Container*.

    > template <typename T>
    > class Container<T>::ContainerIterator {
    >
    > friend class List<T>; // so that List<T> can access private members of
    > Iterator
    > public:
    > // public members
    > private:
    > List<T>::Node * dummyheader;
    > List<T>::Node * ptr;
    > ContainerIterator(const List<T> & l , List<T>::LNode * p);
    > // private members
    > };
    >
    > I forget to declare ContainerIterator class to be a friend of
    > Container class, yet member functions of ContainerIterator can access
    > private members of Container class! For example,
    > ContainerIterator(const List<T> & l , List<T>::LNode * p)
    > {
    > dummyheader = l.header; // ! This works! but why?
    > ptr = p;
    > };


    You access members of List class, not Container class!

    I'm satisfied that if you write other constructor...

    ContainerIterator(const Container<T> & l , Container<T>::LNode * p)
    {
    //!!! dummyheader = l.header; // ! This won't work
    ptr = p;
    };

    ....the compiler will report error.


    --
    mP

    http://pivoluska.matfyz.cz/
    Matej Pivoluska, Dec 13, 2003
    #2
    1. Advertising

  3. CoolPint

    Jeff Guest

    Is Container the same as List? You've shown the definition of one,
    then accessed a member of the other.

    -Jeff

    (CoolPint) wrote in message news:<>...
    > I read in books that nested class cannot access private members of
    > nesting class and vice versa unless they are made friends. Somehow, my
    > compiler is letting my nested class member functions access private
    > members of nesting class.
    >
    > template <typename T>
    > class Container {
    > // NO friendship given to any other
    > public:
    > class ContainerIterator;
    > // other members
    > private:
    > class Node;
    > Node * header;
    > Node * tailer;
    > int counter;
    > };
    >
    > Nested class Node has all of its members as public so that Container
    > members can access them. And then I have the nested Class
    > ContainerIterator, which have both public and private parts.
    >
    > template <typename T>
    > class Container<T>::ContainerIterator {
    >
    > friend class List<T>; // so that List<T> can access private members of
    > Iterator
    > public:
    > // public members
    > private:
    > List<T>::Node * dummyheader;
    > List<T>::Node * ptr;
    > ContainerIterator(const List<T> & l , List<T>::LNode * p);
    > // private members
    > };
    >
    > I forget to declare ContainerIterator class to be a friend of
    > Container class, yet member functions of ContainerIterator can access
    > private members of Container class! For example,
    > ContainerIterator(const List<T> & l , List<T>::LNode * p)
    > {
    > dummyheader = l.header; // ! This works! but why?
    > ptr = p;
    > };
    >
    > So am I misinterpreting the books or is my compiler not following the
    > standard? BTW, I am using g++ 3.2.3. I am quite confused to be honest
    > and would appreciate any help very much. Thanks in advance.
    Jeff, Dec 13, 2003
    #3
  4. CoolPint

    CoolPint Guest

    (Jeff) wrote in message news:<>...
    > Is Container the same as List? You've shown the definition of one,
    > then accessed a member of the other.


    Sorry about the naming. Yes, List is supposed to be Container. I made
    an typing error while trying to copy and paste the section of codes.
    Since I was getting confused myself, I found a simpler sample which
    demonstrate the point I am trying to ask.

    According to the books, the code below should not be compiled since
    nested class "inner" is accessing private member of nesting class
    "enclose" without being declared a friend, but my compiler doesn't say
    anything.

    I want to know if this is the standard behaviour and I made a wrong
    interpretation of the books or it is my compiler doing something
    weird.


    class enclose
    {
    public:
    class inner
    {
    public:
    void f(enclose *e)
    {
    e->x = 1;
    e->y = 2;
    e->z = 3;
    }
    };
    int x;
    protected:
    int y;
    private:
    int z;
    };
    CoolPint, Dec 14, 2003
    #4
  5. CoolPint

    Jeff Schwab Guest

    This one was a surprise to me, too!

    http://www.gnu.org/software/gcc/bugs.html#nonbugs_cxx

    -Jeff

    CoolPint wrote:
    > (Jeff) wrote in message news:<>...
    >
    >>Is Container the same as List? You've shown the definition of one,
    >>then accessed a member of the other.

    >
    >
    > Sorry about the naming. Yes, List is supposed to be Container. I made
    > an typing error while trying to copy and paste the section of codes.
    > Since I was getting confused myself, I found a simpler sample which
    > demonstrate the point I am trying to ask.
    >
    > According to the books, the code below should not be compiled since
    > nested class "inner" is accessing private member of nesting class
    > "enclose" without being declared a friend, but my compiler doesn't say
    > anything.
    >
    > I want to know if this is the standard behaviour and I made a wrong
    > interpretation of the books or it is my compiler doing something
    > weird.
    >
    >
    > class enclose
    > {
    > public:
    > class inner
    > {
    > public:
    > void f(enclose *e)
    > {
    > e->x = 1;
    > e->y = 2;
    > e->z = 3;
    > }
    > };
    > int x;
    > protected:
    > int y;
    > private:
    > int z;
    > };
    Jeff Schwab, Dec 14, 2003
    #5
  6. Jeff Schwab wrote:
    > This one was a surprise to me, too!
    >


    Unfortunately, it won't be the last ....
    Gianni Mariani, Dec 14, 2003
    #6
  7. CoolPint

    Jeff Schwab Guest


    >> This one was a surprise to me, too!

    >
    > Unfortunately, it won't be the last ....


    By definition, since I'd be surprised if it wasn't. :)
    Jeff Schwab, Dec 14, 2003
    #7
  8. CoolPint

    CoolPint Guest

    > Jeff Schwab wrote:
    > > This one was a surprise to me, too!
    > >

    >
    > Unfortunately, it won't be the last ....


    The page you pointed to me says "Non-bugs"...
    Does this mean it's the standard to grant nested classes access to
    private members? (Which means the books I am reading have wrong
    information)

    Or is g++ specific behaviour (which means g++ doesn't follow the
    standard)?
    CoolPint, Dec 14, 2003
    #8
  9. CoolPint

    Jeff Schwab Guest

    CoolPint wrote:
    >>Jeff Schwab wrote:
    >>
    >>>This one was a surprise to me, too!
    >>>

    >>
    >>Unfortunately, it won't be the last ....

    >
    >
    > The page you pointed to me says "Non-bugs"...
    > Does this mean it's the standard to grant nested classes access to
    > private members? (Which means the books I am reading have wrong
    > information)
    >
    > Or is g++ specific behaviour (which means g++ doesn't follow the
    > standard)?


    I believe this means the standard *did not* allow this behavior, but
    someone felt it should. So, they submitted a defect report, and
    proposed the following resolution:

    In 11.8 class.access.nest paragraph 1, change

    The members of a nested class have no special access to members of
    an enclosing class, nor to classes or functions that have granted
    friendship to an enclosing class; the usual access rules (clause 11
    class.access) shall be obeyed.

    to

    A nested class is a member and as such has the same access rights
    as any other member.

    However, I found this among the C++ Standard Core Language Active
    Issues, Revision 28 (Nov. 15, 2003):

    Drafting notes:

    The resolution of core issue 45 (DR) deletes 11.8 class.access.nest

    So, it looks like the standard might just leave the whole thing
    unspecified... Can that be right? Anyway, I think the books you got
    were right, but that the standard is being changed to allow nested
    classes access to all members of the enclosing class.
    Jeff Schwab, Dec 14, 2003
    #9
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Shea Martin
    Replies:
    14
    Views:
    2,778
    SaltPeter
    Apr 10, 2004
  2. Replies:
    2
    Views:
    796
    Noah Roberts
    Jun 9, 2006
  3. mrstephengross
    Replies:
    3
    Views:
    464
  4. Replies:
    2
    Views:
    266
  5. Trans
    Replies:
    10
    Views:
    286
    Sean O'Halpin
    Sep 16, 2005
Loading...

Share This Page