Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > C++ > Can nested class members access private members of nesting class?

Reply
Thread Tools

Can nested class members access private members of nesting class?

 
 
CoolPint
Guest
Posts: n/a
 
      12-13-2003
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.
 
Reply With Quote
 
 
 
 
Matej Pivoluska
Guest
Posts: n/a
 
      12-13-2003
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/
 
Reply With Quote
 
 
 
 
Jeff
Guest
Posts: n/a
 
      12-13-2003
Is Container the same as List? You've shown the definition of one,
then accessed a member of the other.

-Jeff

http://www.velocityreviews.com/forums/(E-Mail Removed) (CoolPint) wrote in message news:<(E-Mail Removed). com>...
> 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.

 
Reply With Quote
 
CoolPint
Guest
Posts: n/a
 
      12-14-2003
(E-Mail Removed) (Jeff) wrote in message news:<(E-Mail Removed) om>...
> 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;
};
 
Reply With Quote
 
Jeff Schwab
Guest
Posts: n/a
 
      12-14-2003
This one was a surprise to me, too!

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

-Jeff

CoolPint wrote:
> (E-Mail Removed) (Jeff) wrote in message news:<(E-Mail Removed) om>...
>
>>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;
> };


 
Reply With Quote
 
Gianni Mariani
Guest
Posts: n/a
 
      12-14-2003
Jeff Schwab wrote:
> This one was a surprise to me, too!
>


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

 
Reply With Quote
 
Jeff Schwab
Guest
Posts: n/a
 
      12-14-2003

>> 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.

 
Reply With Quote
 
CoolPint
Guest
Posts: n/a
 
      12-14-2003
> 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)?
 
Reply With Quote
 
Jeff Schwab
Guest
Posts: n/a
 
      12-14-2003
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.

 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
Can't use class variable with private nested class tron.thomas@verizon.net Python 2 03-29-2007 02:33 AM
Can a sub-class (composite object) member function access private or protected members of base class? pkpatil@gmail.com C++ 2 06-09-2006 03:09 PM
Nested Class, Member Class, Inner Class, Local Class, Anonymous Class E11 Java 1 10-12-2005 03:34 PM
Module.nesting -> Kernel#nesting Trans Ruby 10 09-16-2005 12:21 AM
Public Data in Private Class or Private Data in Public Class? DaveLessnau C++ 3 05-16-2005 06:53 PM



Advertisments