Re: c++/7522: access by friend function's default argument

[Christoph Ludwig <cludwig at cdc dot informatik dot tu-darmstadt dot de>]

On Wed, Oct 30, 2002 at 11:32:04PM -0000, bangerth@dealii.org wrote:
> Synopsis: access by friend function's default argument
> 
> State-Changed-From-To: open->feedback
> State-Changed-By: bangerth
> State-Changed-When: Wed Oct 30 15:32:03 2002
> State-Changed-Why:
>     I don't think this is a bug. 11.0.7 states:
>     7 The  names  in  a  default argument expression (_dcl.fct.default_) are
>       bound at the point of declaration, and access is checked at that point
>       rather than at any points of use of the default argument expression.
>     
>     I don't see anything right away in the standard that for
>     checking access to the names used in the default value has
>     to happen inside the scope of the function that uses them,
>     but common reasoning would suggest that the enclosing scope
>     is used, in which case the befriended function is not
>     taken into account.
>     
>     I'll put this report into feedback mode. Please let us know
>     if you can follow my reasoning, or whether we shall reopen
>     the report.
> 
> http://gcc.gnu.org/cgi-bin/gnatsweb.pl?cmd=view%20audit-trail&database=gcc&pr=7522

I admit I am not totally sure about this. Prior to submitting the PR,
I asked for clarification in comp.lang.c++.moderated and
comp.std.c++, but whithout success.

The reference to 11.0.7 does not totally convince me; as I read it,
the default argument expression has to undergo the same access checks
as any other name bound in the parameter list of the function
declaration. When I prepared an example I found g++ 3.2 seems to apply
the rules inconsistently. Please consider:

 class A {
 private:
     class AInner {
     public:
         AInner(int i);
     };

     static const AInner ai;
     friend void f1(const A::AInner& x);
     friend void f2(const A::AInner& x);
     friend void f3(const A::AInner& x);
 };

 const A::AInner A::ai(5);

 void f1(const A::AInner& x);                  // ok
 void f2(const A::AInner& x = A::AInner(5));   // ok
 void f3(const A::AInner& x = A::ai);          // error


If I follow your reasoning, then all three function declarations
should be flagged as erroneous, I think. But g++ 3.2 complains about
the last declaration only. 

Even if I conceded that only the default argument expressions in this
example should be checked at namespace scope for access violations:
Why should the constructor of the private member class A::AInner be
accessible, but not the private static member variable A::ai?

For what it is worth, Comeau 4.3 accepts the above code.

Regards

Christoph

-- 
http://www.informatik.tu-darmstadt.de/TI/Mitarbeiter/cludwig.html
LiDIA-CA: http://www.informatik.tu-darmstadt.de/TI/Forschung/LiDIA-CA/