在不实例化模板的情况下访问模板化类的公共静态成员？

Question

I have a templated class and want to access a public static variable from outside it, but I can't figure out any way to do so without instantiating the template. This code:

template<class T>
class TemplatedClass {
    public:
        static const int static_member = 10;
};

...

int i = TemplatedClass::static_member;

Produces the following error: "'template class TemplatedClass' used without template parameters."

If I instantiate the class when accessing the variable:

int i = TemplatedClass<int>::static_member;

The error goes away. I would prefer not to have to instantiate a template in a context where it doesn't really make sense with a dummy type argument just to suppress an error. If I have to, what would be the best dummy type to use? I tried <> and <void>, but neither worked.

Answer 1

Can't be done, since specializations might override the value, ie:

template<class T>
class TemplatedClass : public BaseClass
{
    static const int value = 42;
};

template<>
class TemplatedClass<StarTrek>
{
    static const int value = 47;
}

Thus you will get different values:

TemplatedClass<StarTrek>::value != TemplatedClass<void>::value      

If the values are to be equal, I strongly suggest you add a non-template base class:

class BaseClass {
public:
    static const int value = 42;
};

template<class T>
class TemplatedClass : public BaseClass
{
    ...
}

Instantiating or explicitly a dummy type (ie void) might work, but you might get compile errors depending on how you use your template parameter.

int x = TemplatedClass<void>::value;

So, please write code which show your intentions clearly, ie common values for all instantiations should not be in the type-dependent template class. If you can't have that, please explain what you're trying to do in more detail.

Answer 2

Using a dummy type might work for trivial classes, but not if things get more complex.

Let's imagine, that your class "continues" like this:

template<class T>
class TemplatedClass {
public:
    static const int static_member = 10;
    typedef typename std::enable_if< std::is_integral< T >::value >::type type;
};

This code tells us that T cannot be non-integral type.

Upd (thanks to jogojapan): That's why in some cases you cannot use any type as a dummy one