A weird problem of namespace

[meili100]

A program main.cc:

#include <iostream>                                                             
#include <string>                                                               
                                                                                
namespace Test{                                                                 
#define STAR "*"                                                                
}                                                                               
                                                                                
                                                                                
int main(){                                                                     
    std::string str = "this is a test";                                         
    std::string star = "*";                                              
    //std::string star = Test::STAR;                                              
    std::cout<<str<<star<<std::endl;                                          
    return 0;                                                                   
}

It works well. But when I replace

std::string star = "*";

with

std::string star = Test::STAR;

it reports wierd errors like:
main.cc:13: error: `std' undeclared (first use this function)

I suspect it is a problem of namespace. Anybody has a clue?

[laserlight]

#define defines a constant that does not obey the rules of scope since it is a macro.

[cpjust]

The pre-processor runs before the code is compiled, so it knows nothing about namespaces.
Use a static const char* instead.

[Daved]

Why static? I'd just use a const char* or std::string.

[cpjust]

Why static? I'd just use a const char* or std::string.

Doesn't static make global variables local to just one module?

[Elysia]

Yes, it does.

[Daved]

>> Doesn't static make global variables local to just one module?
Then why would they be in a named namespace in the first place? In general, use of static for the purpose of making the variable local to one module has been deprecated.

I don't know whether or how it works to use an unnamed namespace (the preferred alternative) for that purpose with a named namespace as was used in the example.

[dwks]

Making variables static to restrict them to a file is deprecated in C++, in favour of anonymous namespaces (yes, they do work):

static const char *greet = "Hello, World!";  /* in C */
namespace {
    const char *greet = "Hello, World!";  // C++
};

See also:
http://www.glenmccl.com/ns_comp.htm (search for "static")
http://www.informit.com/guides/conte...lus&seqNum=210 (the NOTE at the bottom)
From that last link, it looks like this was the reasoning:

Readers have asked me several times why the C++ standards committee frowned at namespace scope static declarations. The first problem was didactic. The keyword static was already overloaded in C; C++ added to this confusion the concept of static data members and static member functions. The committee felt that static was becoming a Swiss army knife: a single keyword that does too many different things.

Another problem was more subtle. Not all implementations truly support internal linkage. Therefore, the "internal-linkage" promise couldn't be fulfilled in certain environments; hackers familiar with the inner-workings of such implementations could access allegedly-invisible functions and data declared in other translation units. An unnamed namespace, of course, doesn't cure broken linkers; however, it is more honest about its capabilities.

Article 7.3.1.1/1 of the C++ standard says: "[a]lthough entities in an unnamed namespace might have external linkage, they are effectively qualified by a name unique to their translation unit and therefore can never be seen from any other translation unit." Put differently, an unnamed namespace restricts the visibility of its members to the scope of the translation unit by means of name mangling; it doesn't necessarily guarantee internal linkage, though.

For more information, check out that page and others. http://www.google.ca/search?hl=en&q=...amespace&meta=

[Daved]

>> (yes, they do work):
The question is whether they work within a named namespace. Can you make Test::STAR local to the current compilation unit?

[dwks]

Er, sorry . . . good question. I wonder if this would work? Dinkumware seems to think so, but I can't test multiple files with it, unfortunately.

namespace {
    namespace Test {
        const char *STAR = "*";
    }
}

[Mario F.]

namespace {
    namespace Test {
        const char *STAR = "*";
    }
}

You should probably want to do it the other way around, though.

namespace Test {
    namespace  {
        const char *STAR = "*";
    }
}

This way you can guarantee the namespace Test carries over other compilation units, whereas the name Test::STAR is local to this unit.