Manually
您可以做的最简单的事情就是手动滚动代码，我不认为模板可以为您带来太多好处，所以我将使用普通类，其中A, B...代表您类型的特定实例。这允许在编译时初始化类型，但代价是每当将新类型添加到系统时必须记住更新查找表：
typedef void (*function_t)();
function_t func[] = {
&A::f,
&B::f,
&C::f
};
从维护的角度来看，我会推荐这个。系统自动化将使代码将来更难理解和维护。
Macros
最简单、最自动化的宏生成系统可能会生成更少的代码，它只使用宏。由于第一种方法将大量使用宏，因此我将自动生成函数，就像您在上一个问题中所做的那样。如果您（希望）放弃了通过宏生成完整代码的路径，则可以删除该部分代码。
为了避免在不同上下文中重新输入类型名称，您可以使用任何上下文所需的所有数据定义一个宏，然后使用其他宏来过滤每个特定上下文中要使用的内容（以及如何使用）：
// This is the actual list of all types, the id and the code that you were
// generating in the other question for the static function:
#define FOREACH_TYPE( macro ) \
macro( A, 0, { std::cout << "A"; } ) \
macro( B, 1, { std::cout << "B"; } ) \
macro( C, 2, { std::cout << "C"; } )
// Now we use that recursive macro to:
// Create an enum and calculate the number of types used
#define ENUM_ITEM( type, id, code ) \
e_##type,
enum AllTypes {
FOREACH_TYPE( ENUM_ITEM )
AllTypes_count
};
#undef ENUM_ITEM
// Now we can create an array of function pointers
typedef void (*function_t)();
function_t func[ AllTypes_count ];
// We can create all classes:
#define CREATE_TYPE( type, the_id, code ) \
struct type {\
static const int id = the_id; \
static void func() code\
};
FOREACH_TYPE( CREATE_TYPE )
#undef CREATE_TYPE
// And create a function that will
#define REGISTER_TYPE( type, id, code ) \
func[ i++ ] = &type::func;
void perform_registration() {
int i = 0;
FOREACH_TYPE( REGISTER_TYPE );
};
#undef REGISTER_TYPE
// And now we can test it
int main() {
perform_registration();
for ( int i = 0; i < AllTypes_count; ++i ) {
func[ i ]();
}
}
另一方面，这是维护的噩梦，非常脆弱且难以调试。添加新类型很简单，只需在其中添加新行即可FOREACH_TYPE宏，你就完成了......一旦出现问题，祝你好运......
模板和元编程
另一方面，使用模板您可以接近，但无法到达类型的单点定义。您可以通过不同的方式自动执行某些操作，但至少您需要定义类型本身并将它们添加到类型列表中以获得其余功能。
使用 C++0x 代码简化实际 type_list 的定义，您可以从定义类型开始，然后创建type_list。如果您想避免使用 C++0x，请查看 Loki 库，但对于 C++0x，类型列表非常简单：
template <typename ... Args> type_list {}; // generic type list
typedef type_list< A, B, C, D > types; // our concrete list of types A, B, C and D
// this is the only source of duplication:
// types must be defined and added to the
// type_list manually [*]
现在我们需要使用一些元编程来操作类型列表，例如我们可以计算列表中元素的数量：
template <typename List> struct size; // declare
template <typename T, typename ... Args> // general case (recursion)
struct size< type_list<T,Args...> > {
static const int value = 1 + size< type_list<Args...>::value;
};
template <> // stop condition for the recursion
struct size< type_list<> > {
static const int value = 0;
};
拥有类型列表的大小是我们问题的第一步，因为它允许我们定义一个函数数组：
typedef void (*function_t)(); // signature of each function pointer
struct registry {
static const int size = ::size< types >::value;
static const function_t table[ size ];
};
function_t registry::table[ registry::size ]; // define the array of pointers
现在我们想要注册该数组中每个特定类型的静态函数，为此我们创建一个辅助函数（封装为类型中的静态函数以允许部分特化）。请注意，这个具体部分设计为在初始化期间运行：它不会是编译时间，但成本应该微不足道（我会更担心所有模板的二进制大小）：
template <typename T, int N> // declaration
struct register_types_impl;
template <typename T, typename ... Args, int N> // general recursion case
struct register_types_impl< type_list<T,Args...>, N> {
static int apply() {
registry::table[ N ] = &T::f; // register function pointer
return register_types_impl< type_list<Args...>, N+1 >;
}
};
template <int N> // stop condition
struct register_types_impl< type_list<>, int N> {
static int apply() { return N; }
};
// and a nicer interface:
int register_types() {
register_types_impl< types, 0 >();
}
现在我们需要一个 id 函数将我们的类型映射到函数指针，在我们的例子中是类型列表中类型的位置
template <typename T, typename List, int N> // same old, same old... declaration
struct id_impl;
template <typename T, typename U, typename ... Args, int N>
struct id_impl< T, type_list<U, Args...>, N > { // general recursion
static const int value = id_impl< T, type_list<Args...>, N+1 >;
};
template <typename T, typename ... Args, int N> // stop condition 1: type found
struct id_impl< T, type_list<T, Args...>, N> {
static const int value = N;
};
template <typename T, int N> // stop condition 2: type not found
struct id_impl< T, type_list<>, N> {
static const int value = -1;
}
// and a cleaner interface
template <typename T, typename List>
struct id {
static const int value = id_impl<T, List, 0>::value;
};
现在您只需要在运行时触发注册，然后再执行任何其他代码：
int main() {
register_types(); // this will build the lookup table
}
[*] Well... sort of, you can use a macro trick to reuse the types, as the use of macros is limited, it will not be that hard to maintain/debug.
