C ++在类型列表中创建模板特化

Question

I have the following struct:

template<typename tag_type>
struct tag{
    typedef tag_type type;
    enum { value = -1 }
};

I use this class as a typeid to identify specific classes at runtime. Each of these classes needs to be listed in a typelist and each tag specialization needs to have a different value.

Is there a way to make the value equal the index of the specialization in the list.

My goal is to make the maintenance of a list of specialized tag with unique values as easy as possible... (I need to make sure each type in the list has a unique value or part of the system will crash)

EDIT: I failed to mention I use the values at compile time...

Answer 1

A non C++11 implementation of what I think you mean, though you do not really specify the structure of the typelist.

template <typename H, typename T>
struct typelist {
    typedef H head;
    typedef T tail;
};

template <typename T, typename List, int N>
struct typelist_index_i
{
    typedef typename List::tail tail;
    enum {
        value = N + typelist_index_i<T, tail, N + 1>::value
    };
};

template <typename List, int N>
struct typelist_index_i<typename List::tail, List, N>
{
    enum {
        value = N + 1
    };
};
template <typename List, int N>
struct typelist_index_i<typename List::head, List, N>
{
    enum {
        value = N
    };
};

template <typename T, typename List>
struct typelist_index
{
    enum {
        value = typelist_index_i<T, List, 0>::value
    };
};

class A {};
class B {};
class C {};

typedef typelist<A, typelist<B, C> > the_types;

template<typename tag_type>
struct tag{
    typedef tag_type type;
    enum { value = typelist_index<tag_type, the_types>::value };
};

int main()
{
    std::cout << tag<A>::value << std::endl; // 0
    std::cout << tag<B>::value << std::endl; // 1
    std::cout << tag<C>::value << std::endl; // 2

    system("pause");
    return 0;
}

Answer 2

If you don't mind the values not being available until runtime, you could utilize constructors being called for global objects to register the classes for you. Perhaps something like this:

template<typename tag_type>
struct tag {
    typedef tag_type type;
    int value;
    // other info can go here, like a string representation of the class name

    tag(void) {
        register_class(this);
    }
};

#define ADD_CLASS(tag_type) tag<tag_type> __g_tag_ ## tag_type

extern int __g_class_counter;

template<typename tag_type>
static inline void register_class(tag<tag_type> *ptag) {
    ptag->value = __g_class_counter++;
    // TODO: anything else
}

// in some CPP file
int __g_class_counter = 0;

You can then just use the macro ADD_CLASS whenever you need to add a class to the list (you might need to move __g_class_counter elsewhere and make an extern declaration of it).

Answer 3

Is this doing what you want? It is using C++11 features, ie variadic templates. The index_of struct returns the index of a type within a type list or -1 if the type list does not contain the given type. It is a helper struct that is used from within the type_list class. The type_list class gets a list of classes and provides the sub-class template tag , which provides access to the indices of individual types within the list by using the index_of class template.

template <int, class...>
struct index_of;

template <int n, class type, class first, class ... types>
struct index_of<n, type, first, types...>
{
        static constexpr int value = index_of<n+1, type, types...>::value;
};

template <int n, class type, class ... types>
struct index_of<n, type, type, types...>
{
        static constexpr int value = n;
};

template <int n, class type>
struct index_of<n, type>
{
        static constexpr int value = -1;
};

template <class ... types>
struct type_list
{
        template <class type>
        struct tag
        {
            static constexpr int value = index_of<0, type, types...>::value;
        };
};

Usage:

using my_list = type_list<int, float, double>;
std::cout << "Tag of int: " << my_list::tag<int>::value << std::endl;