我可以强制初始化枚举类类/函数模板的所有可能的枚举值吗？

Question

I have a template class using an enum class as template parameter, defined in a header file:

// MyClass.h
enum class MyEnum {FOO, BAR};

template<MyEnum T>class MyClass {
  void doStuff();
  // ...
};

I would like to have the actual implementations of the member functions in a separate source file. I know, that in that case I have to enforce the initialization of the template for each case:

//MyClass.cpp
template<MyEnum T>void MyClass<T>::doStuff() {
  // ...
}
// Implementations of other functions

template class MyClass<MyEnum::FOO>;
template class MyClass<MyEnum::BAR>;

Typically, I know that I need the class with all possible values for the enum anyway, so I would like to tell the compiler that it should actually build the template class for each possible value without explicitly mentioning each possibility .

In other words: I want to replace the last two lines in the example by some automated code.

Is this somehow possible?

I would also like to do the same with template functions instead of a template class.

Answer 1

The normal way to let the compiler know about all the possible specializations is to implement them in the same file. I can't think of a sane way to let the compiler know that a template class is specialized for every value in the domain.

If you have a bazillion of them, you could consider using the X macro pattern . Isolate all your cases in a header file (say MyEnum.h ) like that:

#ifndef HANDLE_ENUM_CASE(e)
#define HANDLE_ENUM_CASE(e)
#endif

HANDLE_ENUM_CASE(FOO)
HANDLE_ENUM_CASE(BAR)
// add more HANDLE_ENUM_CASE(...) expressions for every other case you have

#undef HANDLE_ENUM_CASE

In your source file, you can then have:

enum class MyEnum {
#define HANDLE_ENUM_CASE(e) e,
#include "MyEnum.h"
}

// (class declaration here)

#define HANDLE_ENUM_CASE(e) template class MyClass<MyEnum::e>;
#include "MyEnum.h"

Answer 2

In the old days when enum were just custom names for integer values, it was trivial : we just added a MAX value as the last enum and iterated with a mere for (int i=0; i<MAX; i++) .

If you were using a simple enum MyEnum { FOO, BAR }; you could at least cast a MyEnum to an int, (but not the opposite, would be too easy). But with a enum class MyEnum { FOO, BAR }; casting to an int is no defined either.

So the only C++11 enum way is ... the macro way proposed by zneak ... sniff :-(

If you do not like that ( I don't ) you have to forget enum class and use plain integers, or at least as typedef. And it is not all, a non-type template argument must be a constant expression, so you should also forget the non-type template construct.

It would lead to :

namespace MyEnum {

    typedef int MyEnum_t;
    enum MyEnum : MyEnum_t  { FOO, BAR, MAX };
}

class MyClass {
    MyEnum::MyEnum_t T;
public:
    MyClass(MyEnum::MyEnum_t t): T(t) {}
    void doStuff() {
        std::cout << T << std::endl;
    }
};

You should probably declare a copy constructor that makes sure that you only copy between compatible types, because the compiler can no longer control it. But as least you could do :

for(MyEnum::MyEnum_t e=0; e<MyEnum::MAX; e++) {
    MyClass obj(e);
    obj.doStuff();
}

BTW, as MyClass would no longer be a template, you could safely put the actual implementations of the member functions in a separate source file...