Re: OT: C++ help
On 22/05/2008, Mike Bird <mgb-debian@yosemite.net> wrote:
> On Thu May 22 2008 06:34:27 Jordi Gutiérrez Hermoso wrote:
>
> The first thing to note is that neither of these is your original
> example, so it would be better if you had written "the *only*
> difference between the two examples above is the access specifiers".
The only difference is I added a "using A::f"
> You then complain that it doesn't work when you try to "using" a
> private function.
No, I am "using" a function that is both overloaded to private and
public. But the compiler gets confused depending on the access
specifier. Why should it attempt to use the private function when the
access specifier is public but will happily use the public function
when the access specifier is public?
You keep talking about scope. The access specifier should affect scope
and name resolution? This does not make sense! The public function is
available, a using declaration should bring that function from A's
scope into B's scope, but the compiler tries to resolve the call
"b.f(a)" call to the inaccessible private function anyways. Why should
this make sense?
For the record, both of the snippets above compile on the Comeau C++
compiler, furthering my suspicion that this is a gcc bug.
> Had you quoted the compiler's message to you,
> which was probably "error: 'virtual void A::f(foo)' is private",
I thought you could easily run the programs yourself and see the
compiler error for yourself.
> it would be immediately obvious that EITHER you know nothing of C++
> INCLUSIVE OR you're deliberately wasting bandwidth on this list.
No, I'm just loudmouthed, just as much as you are, and I yell a little
less, too ;-)
> > > But the best solution is to read up on WHY C++ works this way so
> > > you can understand the implications that thousands of great minds
> > > have already pondered.
> >
> > Well, those great minds seem to be too great for me to fathom, because
> > I really don't see why it seems here that a function's signature isn't
> > enough to specify it, and they saw it fit to make sure I couldn't both
> > I overload and inherit three related but different functions.
>
>
> Exactly. Overload ambiguities are resolved in scope, not beyond.
Why do g++ and Comeau disagree here? Shouldn't the using declaration
bring A's functions into scope? Why is it that supposedly bringing
them into scope still results in g++ trying to call the inaccessible
private function and that making that inaccessible private function
public suddenly results in g++ calling the right function that was
public all along?
> Thousands of people, some of them much smarter than
> you or I, have not only decided that C++ should do this (which could
> be a bug) but explained at great length and in great detail why C++
> works this way (thus showing that it is not a bug).
Bah. Thousands of people could never be wrong, eh?
Anyways, I don't think this is thousands of people being wrong, but
just the g++ devs making a small mistake.
> You have been given a precise reference to a good example of such an
> explanation but you ignore it.
Inaccessible. I don't have that book, and it's not in my local library.
> This was offtopic anyway.
I labelled it as such, so that those who didn't want to read about it
could ignore it.
> if you still have questions address them to a C++ forum.
I've done that, but I thought I could pick the brains of Debian users
anyways. If your brain is not available for picking, then just ignore
this thread.
- Jordi G. H.
Reply to: