template constructor

Originally Posted by ISO/IEC 14882:2003(E) Footnote of 7.3.1.1.2

82) Although 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.

Originally Posted by ISO/IEC 14882:2003(E) 2.1

The text of the program is kept in units called source files in this International Standard. A source file together with all the headers (17.4.1.2) and source files included (16.2) via the preprocessing directive #include, less any source lines skipped by any of the conditional inclusion (16.1) preprocessing directives, is called a translation unit. [Note: a C + + program need not all be translated at the same time. ]

Gotta love that C++ standard

Lets see here:

Originally Posted by 14.1.1

template-parameter:
type-parameter
parameter-declaration
type-parameter:
class identifieropt
class identifieropt = type-id
typename identifieropt
typename identifieropt = type-id
template < template-parameter-list > class identifieropt
template < template-parameter-list > class identifieropt = id-expression

Originally Posted by 14.1.3

A type-parameter defines its identifier to be a type-name (if declared with class or typename) or
template-name (if declared with template) in the scope of the template declaration. [Note: because of
the name lookup rules, a template-parameter that could be interpreted as either a non-type templateparameter
or a type-parameter (because its identifier is the name of an already existing class) is taken as a
type-parameter.

Originally Posted by 14.1.4

A non-type template-parameter shall have one of the following (optionally cv-qualified) types:
— integral or enumeration type,
— pointer to object or pointer to function,
— reference to object or reference to function,
— pointer to member.

Originally Posted by 14.1.5-14.1.7

5 [Note: other types are disallowed either explicitly below or implicitly by the rules governing the form of
template-arguments (14.3). ] The top-level cv-qualifiers on the template-parameter are ignored when
determining its type.
6 A non-type non-reference template-parameter is not an lvalue. It shall not be assigned to or in any other
way have its value changed. A non-type non-reference template-parameter cannot have its address taken.
When a non-type non-reference template-parameter is used as an initializer for a reference, a temporary is
always used.

Theres more but I really don't feel like quoting the entire 14.1 section

82) Although entities in an unnamed namespace might have external linkage

so

Code:

namespace{
    char buffer[256];
}

the buffer has external linkage, because no static specified

so
X<buffer> is correct.

Its not really external linkage as no one outside of the translation unit can get to that variable.

Try this:
file1.c

Code:

namespace {
  char buffer[256];
};

file2.c

Code:

extern buffer;
X<buffer>

And tell me if that works.

an unnamed namespace is the new way of saying the deprecated static. Anything in an unnamed namespace is only available to that translation unit in which the namespace is declared therefore linkage is internal.

to Thantos:
take a look at this code

Code:

//file.cpp
namespace {
  char buffer_external[256];       //external linkage
  static char buffer_internal[256];  //internal linkage
};

template<char* P> class X{};

int main()
{
  X<buffer_external> x;   //it's OK, 
  X<buffer_internal> y;    //error, buffer_internal has not external linkage
}

back to your code

Code:

//file1.c
namespace {
  char buffer[256];
};

//file2.c
extern buffer;
X<buffer> x;

now, definition of x is failed, because buffer is in an unnamed namespace and in onther translation unit. but it does not indicate buffer has internal linkage, it still has external linkage, it just says buffer is not available to that translation

refer to

Although 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.

Since you won't listen to me:

Originally Posted by 3.5.1

2 A name is said to have linkage when it might denote the same object, reference, function, type, template, namespace or value as a name introduced by a declaration in another scope:
— When a name has external linkage, the entity it denotes can be referred to by names from scopes of other translation units or from other scopes of the same translation unit.
— When a name has internal linkage, the entity it denotes can be referred to by names from other scopes in the same translation unit.
— When a name has no linkage, the entity it denotes cannot be referred to by names from other scopes.

So if you can't name it in another translational unit then its not external linkage. But don't take my word for it:

Originally Posted by 3.5.4

4 A name having namespace scope has external linkage if it is the name of
— an object or reference, unless it has internal linkage; or
— a function, unless it has internal linkage; or
— a named class (clause 9), or an unnamed class defined in a typedef declaration in which the class has the typedef name for linkage purposes (7.1.3); or
— a named enumeration (7.2), or an unnamed enumeration defined in a typedef declaration in which the enumeration has the typedef name for linkage purposes (7.1.3); or
— an enumerator belonging to an enumeration with external linkage; or
— a template, unless it is a function template that has internal linkage (clause 14); or
— a namespace (7.3), unless it is declared within an unnamed namespace.

Note: All bolding mine

refer to

Originally Posted by 14.3.2
A template-argument for a non-type, non-template template-parameter shall be one of;
- an integral constant-expression of integral or enumeration type; or
- the name of a non-type template-parameter; or
- the name of an object or function with external linkage, including function templates and function template-ids but excluding non-static class members. expressed as & id-expression where the & is optional if the name refers to a function or array; or
- a pointer to member expressed as described in 5.3.1

what about this code

Code:

namespace {
  char buffer_external[256];       //external linkage
  static char buffer_internal[256];  //internal linkage
};

template<char* P> class X{};

int main()
{
  X<buffer_external> x;   //it's OK, 
  X<buffer_internal> y;    //error, buffer_internal has not external linkage
}

if buffer_external has internal linkage, how can be X<buffer_external> legal ?

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

I'm done with this. Anyone else want to try?

nah not worth the energy.