Dynamic dispatching of template functions?

by

A typical ‘trick’ to bridge compile time and runtime when dealing with templates is visiting a variant type. That’s what the Generic Image Library (available as Boost.GIL or standalone) does for instance. It typically takes the form of:

typedef boost::variant<T, U, V> variant_type;
variant_type variant = /* type is picked at runtime */
boost::apply_visitor(visitor(), variant);

where visitor is a polymorphic functor that simply forwards to the template:

struct visitor: boost::static_visitor<> {
    template<typename T>
    void
    operator()(T const& t) const
    { foo(t); } // the real work is in template<typename T> void foo(T const&);
};

This has the nice design that the list of types that the template will/can be instantiated with (here, the variant_type type synonym) is not coupled to the rest of the code. Metafunctions like boost::make_variant_over also allows computations over the list of types to use.

Since this technique is not available to non-type parameters, you need to ‘unroll’ the visitation by hand, which unfortunately means the code is not as readable/maintainable.

void
bar(int i) {
    switch(i) {
        case 0: A<0>::f(); break;
        case 1: A<1>::f(); break;
        case 2: A<2>::f(); break;

        default:
            // handle
    }
}

The usual way to deal with the repetition in the above switch is to (ab)use the preprocessor. An (untested) example using Boost.Preprocessor:

#ifndef LIMIT
 #define LIMIT 20 // 'reasonable' default if nothing is supplied at build time
#endif
#define PASTE(rep, n, _) case n: A< n >::f(); break;

void
bar(int i) {
    switch(i) {
        BOOST_PP_REPEAT(LIMIT, PASTE, _)

        default:
            // handle
    }
}

#undef PASTE
#undef LIMIT

Better find good, self-documenting names for LIMIT (wouldn’t hurt for PASTE either), and limit the above code-generation to just one site.

Building from David’s solution and your comments:

template<int... Indices>
struct indices {
    typedef indices<Indices..., sizeof...(Indices)> next;
};

template<int N>
struct build_indices {
    typedef typename build_indices<N - 1>::type::next type;
};

template<>
struct build_indices<0> {
    typedef indices<> type;
};

template<int... Indices>
void
bar(int i, indices<Indices...>)
{
    static void (*lookup[])() = { &A<Indices>::f... };
    lookup[i]();
}

then to call bar: bar(i, typename build_indices<N>::type()) where N would be your constant-time constant, sizeof...(something). You can add a layer to hide the ‘ugliness’ of that call:

template<int N>
void
bar(int i)
{ bar(i, typename build_indices<N>::type()); }

which is called as bar<N>(i).

More Related Contents:

  1. Optimization code for a debug function (c++11 with templates) [closed]
  2. Check if a class has a member function of a given signature
  3. std::enable_if to conditionally compile a member function
  4. C++11 does not deduce type when std::function or lambda functions are involved
  5. Variadic template pack expansion
  6. std::function vs template
  7. initializer_list and template type deduction
  8. What is the partial ordering procedure in template deduction
  9. trailing return type using decltype with a variadic template function
  10. When to use std::forward to forward arguments?
  11. C++11: I can go from multiple args to tuple, but can I go from tuple to multiple args? [duplicate]
  12. Matching alias template as template argument
  13. How do compilers treat variable length arrays
  14. What does this variadic template code do?
  15. SFINAE works differently in cases of type and non-type template parameters
  16. void_t “can implement concepts”?
  17. How can I output the value of an enum class in C++11
  18. How Does std::enable_if work?
  19. Can the point-of-instantiation be delayed until the end of the translation unit?
  20. How to pass a template function in a template argument list
  21. Is there a compiler bug exposed by my implementation of an is_complete type trait?
  22. Returning a void?
  23. Passing a lambda into a function template
  24. How to typedef a template class? [duplicate]
  25. using SFINAE for template class specialisation
  26. Why does the template-id in “A=0” not compile without space because of the greater-or-equal-than operator “>=”?
  27. Specializing a template on a lambda in C++0x
  28. Partial specialization of function templates
  29. Concatenate compile-time strings in a template at compile time?
  30. using extern template (C++11) to avoid instantiation

Leave a Comment