Experiment with unnamed namespace and template

[Johannes Schaub (litb)]

I have this code:

namespace {
template <class T>
struct Template { /* ... */ };
}

typedef Template<int> Template;


Can we put code after it to create an object of type `Template<float>`?
Reopening the unnamed namespace is not allowed. All code should be
afterwards!

I think there are a couple of solutions. What are the most crazy ones?

 

[Victor Bazarov]

I have this code:

namespace {
template<class T>
struct Template { /* ... */ };
}

typedef Template<int> Template;

So, the name ::Template refers to the typedef, then.

Can we put code after it to create an object of type `Template<float>`?
Reopening the unnamed namespace is not allowed.

What do you mean by "not allowed"?

> All code should be
afterwards!

I think there are a couple of solutions. What are the most crazy ones?

namespace {
template <class T>
struct Template { /* ... */ };
}

typedef Template<int> Template;

// reopening - miracle!
namespace {
typedef Template<float> fTemplate;
}

int main()
{
::Template a; // creates an object of type Template<int>
fTemplate f; // here is your Template<float>
}


V

 

[Johannes Schaub (litb)]

So, the name ::Template refers to the typedef, then.


What do you mean by "not allowed"?

In this experiment, it's not allowed.

 

[Luc Danton]

I have this code:

namespace {
template<class T>
struct Template { /* ... */ };
}

typedef Template<int> Template;


Can we put code after it to create an object of type `Template<float>`?
Reopening the unnamed namespace is not allowed. All code should be
afterwards!

I think there are a couple of solutions. What are the most crazy ones?

I did:

namespace {

template<class T>
class Template {};

} // namespace

typedef Template<int> Template;

template<typename Target, typename Source, typename T>
struct retarget;

template<
typename Target,
typename Source,

>

struct retarget<Target, Source, T<Source> > {
typedef T<Target> type;
}

int
main()
{
retarget<float, int, ::Template>::type();
}

It compiled fine in C++03 conformant mode. (Note that as I tested the
code on another machine so it is not copied verbatim, there might be
errors in the above.) I then added an explicit specialisation
Template<float> with a static_assert inside to check the right type was
being instanciated and it was triggered. (In C++0x mode this time for
static_assert.)

Doesn't seem that crazy to me though.

 

[Victor Bazarov]

In this experiment, it's not allowed.

Ah...

V