[Bug 45770] (c++) New: global access allowance exceeds that of derived class

[Bug 45770] (c++) New: global access allowance exceeds that of derived class

[MichieldeB at aim dot com]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=45770

           Summary: global access allowance exceeds that of derived class
           Product: gcc
           Version: unknown
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c++
        AssignedTo: unassigned@gcc.gnu.org
        ReportedBy: MichieldeB@aim.com


// g++ (Ubuntu 4.4.3-4ubuntu5) 4.4.3
// Copyright (C) 2009 Free Software Foundation, Inc.
// This is free software; see the source for copying conditions.  There is NO
// warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

class A
{

friend class B;

public:
  A(int i) { a = i; }

private:
  A() { a = 0; }
  int a;

};

class B : private A // making protected will eliminate the below problem
{

public:
  B(int i) : A () { a = i >> 1; b = i & 1; }

private:
  bool b;

};

class C : public B
{

public:
  C() : B(4) { A foo(3); } // functions of B may not have local variables A

};             

main () { A bar(3); } // main may have local variables A

-- 
Configure bugmail: http://gcc.gnu.org/bugzilla/userprefs.cgi?tab=email
------- You are receiving this mail because: -------
You are on the CC list for the bug.

[Bug 45770] (c++) global access allowance exceeds that of derived class

[pinskia at gcc dot gnu.org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=45770

Andrew Pinski <pinskia at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|UNCONFIRMED                 |RESOLVED
         Resolution|                            |INVALID

--- Comment #1 from Andrew Pinski <pinskia at gcc dot gnu.org> 2010-09-23 23:16:16 UTC ---
This is correct as the A here is injected via the inheirtance of the class.  If
you want to use the name the global A, use ::A.

-- 
Configure bugmail: http://gcc.gnu.org/bugzilla/userprefs.cgi?tab=email
------- You are receiving this mail because: -------
You are on the CC list for the bug.

[Bug c++/45770] global access allowance exceeds that of derived class

[MichieldeB at aim dot com]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=45770

MichieldeB at aim dot com changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|RESOLVED                    |UNCONFIRMED
         Resolution|INVALID                     |

--- Comment #2 from MichieldeB at aim dot com 2010-09-24 21:53:56 UTC ---
// If the access of locals should be inherited, then the following is a bug.

// g++ (Ubuntu 4.4.3-4ubuntu5) 4.4.3
// Copyright (C) 2009 Free Software Foundation, Inc.
// This is free software; see the source for copying conditions.  There is NO
// warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

class A
{

friend class B;

public:
  A(int i) { a = i; }

private:
  A() { a = 0; }
  int a;

};

class B : private A // making protected will allow local variables A below
{

public:
  B(int i) : A () { a = i >> 1; b = i & 1; }

private:
  bool b;

};

class C : public B
{

public:
  C() : B(4) { ::A foo(3); } // functions of B may have local variables ::A
                             // but not A
};             

template <class T, class U> class D : private T
{
  D(int i) : T(i) { U u; } 
};  

template class D<A,A>; // local A gets global access rights

main () { ::A bar(3); } // main may have local variables A

-- 
Configure bugmail: http://gcc.gnu.org/bugzilla/userprefs.cgi?tab=email
------- You are receiving this mail because: -------
You are on the CC list for the bug.

[Bug c++/45770] global access allowance exceeds that of derived class

[pinskia at gcc dot gnu.org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=45770

Andrew Pinski <pinskia at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|UNCONFIRMED                 |RESOLVED
         Resolution|                            |INVALID

--- Comment #3 from Andrew Pinski <pinskia at gcc dot gnu.org> 2010-09-24 21:58:44 UTC ---
> access of locals 

Huh?  That is not what I am saying.  What I am saying is that A names (inside
C) the injected name in B which is private.

The reason why:
template <class T, class U> class D : private T
{
  D(int i) : T(i) { U u; } 
};  

template class D<A,A>; // local A gets global access rights
--- CUT ---

Works is because the names you are using are T and U and not A.

-- 
Configure bugmail: http://gcc.gnu.org/bugzilla/userprefs.cgi?tab=email
------- You are receiving this mail because: -------
You are on the CC list for the bug.

[Bug c++/45770] global access allowance exceeds that of derived class

[MichieldeB at aim dot com]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=45770

MichieldeB at aim dot com changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|RESOLVED                    |UNCONFIRMED
         Resolution|INVALID                     |

--- Comment #4 from MichieldeB at aim dot com 2010-09-26 18:14:26 UTC ---
My last counterexample was invalid, sorry. Furthermore, the problem does not
seem a template problem. I now have an example where the local object has lower
rights than the inherited object, thus no access inheritance for the local.

// g++ (Ubuntu 4.4.3-4ubuntu5) 4.4.3
// Copyright (C) 2009 Free Software Foundation, Inc.
// This is free software; see the source for copying conditions.  There is NO
// warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

class A
{

friend class B;

public:
  A(int i) { a = i; }

protected:
  A(int i, int j) { a = i ^ j; }

private:
  A() { a = 0; }
  int a;

};

class B : private A // making protected will allow local variables A below
{

public:
  B(int i) : A () { a = i >> 1; b = i & 1; }

private:
  bool b;

};

class C : public B
{

public:
  C() : B(4) { ::A foo(3); } // functions of B may have local variables ::A
                             // but not A
};            

class D : public A
{
  friend class D;

  D(int i, int j) : A(i,j) 
  { 
    A d(i,j); // friend class D of class D has no inherited rights here
              // note that friends do not have inherited objects in general
  }  
};  

main () { A bar(3); } // main may have local variables A

[Bug c++/45770] global access allowance exceeds that of derived class

[paolo.carlini at oracle dot com]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=45770

Paolo Carlini <paolo.carlini at oracle dot com> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |paolo.carlini at oracle dot
                   |                            |com

--- Comment #5 from Paolo Carlini <paolo.carlini at oracle dot com> 2010-09-26 18:25:29 UTC ---
Without having looked into your last snippet, I note that the Intel Compiler,
VC++, and Comeau also reject it.

[Bug c++/45770] global access allowance exceeds that of derived class

[redi at gcc dot gnu.org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=45770

Jonathan Wakely <redi at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|UNCONFIRMED                 |RESOLVED
         Resolution|                            |INVALID

--- Comment #6 from Jonathan Wakely <redi at gcc dot gnu.org> 2010-09-26 19:36:39 UTC ---
(In reply to comment #4)
> 
> class A
> {
> 
> friend class B;
> 
> public:
>   A(int i) { a = i; }
> 
> protected:
>   A(int i, int j) { a = i ^ j; }
> 
> private:
>   A() { a = 0; }
>   int a;
> 
> };
> 
> class B : private A // making protected will allow local variables A below
> {
> 
> public:
>   B(int i) : A () { a = i >> 1; b = i & 1; }

B is a friend of A so can call the private constructor.

> private:
>   bool b;
> 
> };
> 
> class C : public B
> {
> 
> public:
>   C() : B(4) { ::A foo(3); } // functions of B may have local variables ::A
>                              // but not A

A(int) is public, so it can be called

> };            
> 
> class D : public A
> {
>   friend class D;

What is this supposed to do?

> 
>   D(int i, int j) : A(i,j) 

A(int, int) is protected, so D can call it on its base sub-object

>   { 
>     A d(i,j); // friend class D of class D has no inherited rights here
>               // note that friends do not have inherited objects in general

The object 'd' is not a sub-object of D, so there is no access to that
constructor from D's member functions.

>   }  
> };  
> 
> main () { A bar(3); } // main may have local variables A

That constructor is public, so of course it can.

Your example is not valid C++, that's not a problem with GCC.