question about anonymous namespace...

[Luna Moon]

I am reading the book "C++ Annotations", and here is a quote from the
book:

Namespaces can be defined without a name. Such a namespace is
anonymous and it restricts the
visibility of the defined entities to the source file in which the
anonymous namespace is defined.
Entities defined in the anonymous namespace are comparable to C’s
static functions and variables.
In C++ the static keyword can still be used, but its use is more
common in class definitions
(see chapter 6). In situations where static variables or functions are
necessary, the use of the
anonymous namespace is preferred.
--------------

Could anybody give me an example about why the anonymous name space is
the same as "static" variables and functions in C?

thanks!

[Ian Collins]

Luna Moon wrote:

I am reading the book "C++ Annotations", and here is a quote from the
book:

Namespaces can be defined without a name. Such a namespace is
anonymous and it restricts the
visibility of the defined entities to the source file in which the
anonymous namespace is defined.
Entities defined in the anonymous namespace are comparable to C’s
static functions and variables.
In C++ the static keyword can still be used, but its use is more
common in class definitions
(see chapter 6). In situations where static variables or functions are
necessary, the use of the
anonymous namespace is preferred.
--------------

Could anybody give me an example about why the anonymous name space is
the same as "static" variables and functions in C?

The quote says it all: "it restricts the visibility of the defined
entities to the source file in which the anonymous namespace is defined"

Which is exactly what "static" does in C.

--
Ian Collins

[blargg]

In article
<4b************ *************** *******@a29g200 0pra.googlegrou ps.com>, Luna
Moon <lu**********@g mail.comwrote:

I am reading the book "C++ Annotations", and here is a quote from the
book:

Namespaces can be defined without a name. Such a namespace is
anonymous and it restricts the visibility of the defined entities
to the source file in which the anonymous namespace is defined.
Entities defined in the anonymous namespace are comparable to C's
static functions and variables. In C++ the static keyword can still
be used, but its use is more common in class definitions (see
chapter 6). In situations where static variables or functions are
necessary, the use of the anonymous namespace is preferred.

--------------

Could anybody give me an example about why the anonymous name space is
the same as "static" variables and functions in C?

Why? Because the standard says so. Actually, the effect is not exactly the same.

// Before namespace
static int i;
static void f() { }
struct my_foo { };

// After namespace
namespace
{
int i;
void f() { }
struct foo { }; // no need for prefix on name, since it's now a local name
}

BTW, the proper term is "unnamed namespace" (C++03 7.3.1.1). The author of
the C++ book you're reading should have taken the time to get it right.

[James Kanze]

On Oct 23, 9:08 am, blargg....@gish puppy.com (blargg) wrote:

In article
<4b97d33c-17f1-4bf8-a02b-71ca05250...@a2 9g2000pra.googl egroups.com>,
Luna Moon <lunamoonm...@g mail.comwrote:

[...]

Could anybody give me an example about why the anonymous
name space is the same as "static" variables and functions
in C?

Why? Because the standard says so. Actually, the effect is not
exactly the same.

// Before namespace
static int i;
static void f() { }
struct my_foo { };

// After namespace
namespace
{
int i;
void f() { }
struct foo { }; // no need for prefix on name, since it's now a localname
}

Another important difference is the linkage of the name. A
static variable or function has internal linkage. A name in an
anonymous namespace has external linkage---the reason it can't
be seen from other translation units is that it isn't namable in
them. (Formally, it is visible everywhere, but since it can't
be named, there's no way to actually see it.) A template can
only be instantiated over something that has external linkage,
e.g.:

template< int* p class T {} ;

static int i ;
namespace {
int j ;
}

T< &i ti ; // illegal...
T< &j tj ; // legal.

BTW, the proper term is "unnamed namespace" (C++03 7.3.1.1).
The author of the C++ book you're reading should have taken
the time to get it right.

The term anonymous namespace seems pretty widespread to me.

--
James Kanze (GABI Software) email:ja******* **@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[spambouncer]

... A template can only be instantiated over something that

has external linkage, e.g.:

template< int* p class T {} ;

static int i ;
namespace {
int j ;
}

T< &i ti ; // illegal...
T< &j tj ; // legal.

To me, anonymous namespaces were just the C++ way of saying static.
The external linkage point is new to me. But:

Pointer-to-int as template argument? Instantiating templates over
something with external linkage? Could you provide a practical example
working with anonymous namespace but not working with static? Note
that you could also omit the static keyword to the same effect.

BTW, the proper term is "unnamed namespace" (C++03 7.3.1.1).
The author of the C++ book you're reading should have taken
the time to get it right.

The term anonymous namespace seems pretty widespread to me.

I'd bet a horse and a carrot that "unnamed" is the literal meaning of
"anonymous" .

Best regards,
Andreas.

[Michael Mol]

On Oct 23, 3:08*am, blargg....@gish puppy.com (blargg) wrote:

[snip]

// Before namespace
static int i;
static void f() { }
struct my_foo { };

// After namespace
namespace
{
* * int i;
* * void f() { }
* * struct foo { }; // no need for prefix on name, since it's now a local name

}

Now I'm curious. Take the following code from the same compilation
unit:

namespace
{
int i;
void x() { }
}

namespace
{
int j;
void y() { }
}

Would i be visible to y(), and j be visible to x()?

[Pete Becker]

On 2008-10-23 12:23:54 -0400, Michael Mol <mi*****@gmail. comsaid:

On Oct 23, 3:08Â*am, blargg....@gish puppy.com (blargg) wrote:

[snip]

>// Before namespace
static int i;
static void f() { }
struct my_foo { };

// After namespace
namespace
{
Â* Â* int i;
Â* Â* void f() { }
Â* Â* struct foo { }; // no need for prefix on name, since it's now a l

ocal name

>>
}

Now I'm curious. Take the following code from the same compilation
unit:

namespace
{
int i;
void x() { }
}

namespace
{
int j;
void y() { }
}

Would i be visible to y(),

yes.

and j be visible to x()?

no.

Same answer with a named namespace and without a namespace.

--
Pete
Roundhouse Consulting, Ltd. (www.versatilecoding.com) Author of "The
Standard C++ Library Extensions: a Tutorial and Reference
(www.petebecker.com/tr1book)

[spambouncer]

Now I'm curious. Take the following code from the same compilation

unit:

namespace
{
int i;
void x() { }
}

namespace
{
int j;
void y() { }
}

Would i be visible to y(), and j be visible to x()?

Generally, namespaces can be split across several compilation units.
The only exception to this rule are anonymous namespaces. If you would
split an anonymous namespace across several compilation units, it
wouldn't be the same namespace. That's because anonymous namespaces
are not truely anonymous, it's just that their name is not accessible
by the coder. The compiler, however, assigns a unique ID to them per
compilation unit.

But, as you're asking for the same compilation unit, yes, i is visible
to y(), and no, j is not visible to x().

Best regards,
Andreas.

[blargg]

In article
<34************ *************** *******@g61g200 0hsf.googlegrou ps.com>,
Michael Mol <mi*****@gmail. comwrote:

On Oct 23, 3:08 am, blargg....@gish puppy.com (blargg) wrote:

[snip]

// Before namespace
static int i;
static void f() { }
struct my_foo { };

// After namespace
namespace
{
int i;
void f() { }
struct foo { }; // no need for prefix on name, since it's now a
// local name

}

Now I'm curious. Take the following code from the same compilation
unit:

namespace
{
int i;
void x() { }
}

namespace
{
int j;
void y() { }
}

Would i be visible to y(), and j be visible to x()?

Heck, since we're talking about the same translation unit, you could also add

// at file scope in same translation unit
void z()
{
i = 0;
j = 0;
x();
y();
}

and it would see everything in your unnamed namespaces (and z would be
visible to other translation units).

[James Kanze]

On Oct 23, 5:35*pm, "spamboun...@gm x.de" <spamboun...@gm x.dewrote:

... A template can only be instantiated over something that
has external linkage, e.g.:

* * template< int* p class T {} ;

* * static int i ;
* * namespace {
* * * * int j ;
* * }

* * T< &i ti ; * // *illegal...
* * T< &j tj ; * // *legal.

To me, anonymous namespaces were just the C++ way of saying
static. The external linkage point is new to me. But:

Pointer-to-int as template argument?

Why not? It was the simplest example that came to my mind.

Instantiating templates over something with external linkage?

Anything you use to instantiate a template must have external
linkage. Those are the rules.

Could you provide a practical example working with anonymous
namespace but not working with static?

I just did. See above: declare the variable static, and you
can't use it to instantiate the template. Define it in an
anonymous namespace, and you can.

I run into this a lot because of const; const is static by
default, so something like:

template< int* p class T{} ;

namespace {
int const i = 43 ;
}

T< &i t ; // illegal.

You have to define the int:
extern int const i = 43 ;

(In practice, of course, most of the time, it's a user defined
class, and the template parameter is a reference, rather than a
pointer, and it's a function template, not a class template.
But the same principles apply.)

Note that you could also omit the static keyword to the same
effect.

Except that if I omitted the static keyword in my example, the
symbol would be visible in every module. And conflict with
another module which did exactly the same thing with the same
name.

BTW, the proper term is "unnamed namespace" (C++03 7.3.1.1).
The author of the C++ book you're reading should have taken
the time to get it right.

The term anonymous namespace seems pretty widespread to me.

I'd bet a horse and a carrot that "unnamed" is the literal
meaning of "anonymous" .

Actually, no. From the way I understand English, anonymous
means that the name is hidden, and not visible; unnamed means
that it doesn't exist. In which case, anonymous is actually
closer to what really happens.

--
James Kanze (GABI Software) email:ja******* **@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]