This is the mail archive of the
gdb@sources.redhat.com
mailing list for the GDB project.
Re: C++ namespace using directives
- From: Don Howard <dhoward at redhat dot com>
- To: Jim Blandy <jimb at redhat dot com>
- Cc: <gdb at sources dot redhat dot com>
- Date: Mon, 29 Apr 2002 14:25:17 -0700 (PDT)
- Subject: Re: C++ namespace using directives
On 29 Apr 2002, Jim Blandy wrote:
>
> Don Howard <dhoward@redhat.com> writes:
> > On Tue, 16 Apr 2002, Jim Blandy wrote:
> > > Could a C++ person check my understanding of `using namespace'
> > > directives?
> > >
> > > I'm reading Stroustrup, and the more I read about `using namespace',
> > > the weirder it gets. Check this out:
> > >
> > > namespace A
> > > {
> > > int x;
> > > int y;
> > > int z;
> > > };
> > >
> > > void f ()
> > > {
> > > int *x;
> > >
> > > {
> > > int *y;
> > > using namespace A;
> > >
> > > *x; /* `x' refers to local x, not A::x */
> > > *y; /* `y` refers to local y, not A::y */
> > > z; /* `z' refers to A::z */
> > > }
> > > }
> >
> > This example seems correct to me, as the compiler can dis-ambiguate based
> > on type-- dereference works on pointers, so x and y must refer to the
> > local versions.
>
> No, that's not what's going on at all. In Stroustrup's example, there
> is no dereferencing going on, and he makes the same claims about which
> binding each reference refers to as I do. I added the dereferences as
> a sanity check, to make sure GCC was doing the right thing.
So the Stroustrup example looks like this:
namespace A
{
int x = 10;
int y = 20;
int z = 30;
};
int x = 100;
void f ()
{
int x = 0;
{
int y = 0;
using namespace A;
x = 1;
y = 2;
z = 42; // Which one is not like the others... This one.
printf ("A::x == %d\nA::y == %d\nA::z == %d\nx == %d\ny == %d\n::x == %d\n",
A::x, A::y, A::z, x, y, ::x);
}
}
int main (void)
{
f ();
}
....
franklinstower$ ./foo
A::x == 10
A::y == 20
A::z == 42
x == 1
y == 2
::x == 100
>
> So you see why I think this behavior is way wacky? The `using
> namespace' directive appears in the inner block, the local definition
> appears in the outer block, but references to `x' in the inner block
> still see the local definition in the outer block.
Yes, I expected the 'using namespace' directive to affect scoping rules
somehow, but that isn't what it does. Hmm. reading Stroustrup's reasoning
makes this more clear. He wanted to implement a backward compatable way
to partition namespaces -- one that would not require existing code to be
changed. To that end, the 'using namespace' directive is not a scope
resolution operator. The statement 'using namespace A' just makes the
members of A available to the local block at global (?) scope (does that
make sense?).
So the following doesn't compile due to ambiguity:
namespace A
{
...
int z;
}
int z;
...
{
using namespace A;
z = 42;
}
[And it I just found Gaby Dos Reis' response to your first mail, which
says just what I spent 30 minutes looking up...]
--
dhoward@redhat.com
gdb engineering