Question

Here is my problem: in a header I define a structure template type_to_string, which aims at defining a string corresponding to a given type argument:

namespace foo {

    template <typename T>
    struct type_to_string
    {
        static const char * value;
    };
}

template <typename T>
const char * foo::type_to_string<T>::value = "???";

I also define a default value for the string.

Now, I’d want to use a macro for defining new types:

#define CREATE_ID(name)                               \
struct name;                                          \
                                                      \
template<>                                            \
const char * foo::type_to_string<name>::value = #name;

The problem is that I’d like the macro to be usable in namespaces, as in:

namespace bar
{
    CREATE_ID(baz)
}

which is not possible because type_to_string<T>::value must be defined in a namespace enclosing foo.

Here is the compilation errors I get:

[COMEAU 4.3.10.1] error: member "foo::type_to_string<T>::value [with T=bar::baz]"
cannot be specialized in the current scope

[VISUAL C++ 2008] error C2888: 'const char *foo::type_to_string<T>::value' :
symbol cannot be defined within namespace 'bar'
     with
     [
         T=bar::baz
     ]

Strangely, GCC 4.3.5 (MinGW version) doesn’t produce any errors.

Does anyone know a workaround for this, maybe by using some lookup rules I’m not aware of (i.e. declaring type_to_string in the macro so that each namespace has its own version, or something like that)?

Answer 1

According to C++ Standard 14.7.3/2:

An explicit specialization shall be declared in the namespace of which the template is a member, or, for
member templates, in the namespace of which the enclosing class or enclosing class template is a member.
An explicit specialization of a member function, member class or static data member of a class template
shall be declared in the namespace of which the class template is a member. Such a declaration may also
be a definition. If the declaration is not a definition, the specialization may be defined later in the name-
space in which the explicit specialization was declared, or in a namespace that encloses the one in which
the explicit specialization was declared.

You could write something like the following:

#define DECL_ID(name) \
struct name;                                          

#define CREATE_ID(name) \
template<>              \
const char * foo::type_to_string<name>::value = #name;

namespace bar { namespace bar2 {
    DECL_ID(baz)
} }
CREATE_ID(bar::bar2::baz)

Or

#define CREATE_ID(ns, name)     \
namespace ns { struct name; }   \
                                \
template<>                      \
const char * foo::type_to_string<ns::name>::value = #name;

CREATE_ID(bar, baz)

The third option is superposition of first two. It allows to have unqualified name in value (if it is required):

#define DECL_ID(name) \
struct name;                                          

#define CREATE_ID(ns, name) \
template<>              \
const char * foo::type_to_string<ns::name>::value = #name;

namespace bar { namespace bar2 {
    DECL_ID(baz)
} }
CREATE_ID(bar::bar2, baz)