Specify template parameters at runtime

by

Here’s what you can do:

MyClassInterface* Factor(int p1, int p2, int p3) {
  if (p1 == 0 && p2 == 0 && p3 == 0)
    return new MyClass<0,0,0>();
  if (p1 == 0 && p2 == 0 && p3 == 1)
    return new MyClass<0,0,1>();
  etc;
}

Note that this does not even remotely scale to floating point values. It scales only to a known list of discrete values.

I’ve also used this bit of code before to do some template automatic generation:

#include <boost/preprocessor.hpp>

#define RANGE ((0)(1)(2)(3)(4)(5)(6)(7)(8)(9)(10)(11)(12))
#define MACRO(r, p) \
    if (BOOST_PP_SEQ_ELEM(0, p) == var1 && BOOST_PP_SEQ_ELEM(1, p) == var2 && BOOST_PP_SEQ_ELEM(2, p) == var3 && BOOST_PP_SEQ_ELEM(3, p) == var4) \
        actual_foo = foo<BOOST_PP_TUPLE_REM_CTOR(4, BOOST_PP_SEQ_TO_TUPLE(p))>;
BOOST_PP_SEQ_FOR_EACH_PRODUCT(MACRO, RANGE RANGE RANGE RANGE)
#undef MACRO
#undef RANGE

The compiler produces output that looks like this:

if (0 == var1 && 0 == var2 && 0 == var3 && 0 == var4) actual_foo = foo<0, 0, 0, 0>;
if (0 == var1 && 0 == var2 && 0 == var3 && 1 == var4) actual_foo = foo<0, 0, 0, 1>;
if (0 == var1 && 0 == var2 && 0 == var3 && 2 == var4) actual_foo = foo<0, 0, 0, 2>;
if (0 == var1 && 0 == var2 && 0 == var3 && 3 == var4) actual_foo = foo<0, 0, 0, 3>;
if (0 == var1 && 0 == var2 && 0 == var3 && 4 == var4) actual_foo = foo<0, 0, 0, 4>; 
if (0 == var1 && 0 == var2 && 0 == var3 && 5 == var4) actual_foo = foo<0, 0, 0, 5>;
if (0 == var1 && 0 == var2 && 0 == var3 && 6 == var4) actual_foo = foo<0, 0, 0, 6>;
if (0 == var1 && 0 == var2 && 0 == var3 && 7 == var4) actual_foo = foo<0, 0, 0, 7>;
if (0 == var1 && 0 == var2 && 0 == var3 && 8 == var4) actual_foo = foo<0, 0, 0, 8>;
etc...

Also, please note that with this method, with 4 variables, each ranging over 13 values, You would cause the compiler to instantiate 28561 copies of this function. If your n was 50, and you still had 4 options, you would have 6250000 functions instantiated. This can make for a SLOW compile.

More Related Contents:

  1. Why do i have a random result on this template?
  2. Templated check for the existence of a class member function?
  3. How does `void_t` work
  4. using extern template (C++11)
  5. Does C++ support compile-time counters?
  6. SFINAE working in return type but not as template parameter
  7. C++ function template partial specialization?
  8. C++ invoke explicit template constructor
  9. C++ syntax for explicit specialization of a template function in a template class?
  10. Template deduction for function based on its return type?
  11. How to achieve “virtual template function” in C++
  12. Template static variable
  13. constant references with typedef and templates in c++
  14. Is it possible to “store” a template parameter pack without expanding it?
  15. Deduce template argument from std::function call signature
  16. How to reverse the order of arguments of a variadic template function?
  17. Template specialization and enable_if problems [duplicate]
  18. Populate An Array Using Constexpr at Compile-time
  19. Why is it not possible to overload class templates?
  20. Why do auto and template type deduction differ for braced initializers?
  21. Lambda expressions as class template parameters
  22. Do c++ templates make programs slow?
  23. Using export keyword with templates
  24. How to make a variadic is_same?
  25. Understanding (simple?) C++ Partial Template Specialization
  26. Default template parameter partial specialization
  27. Does reinterpret_cast lead to undefined behavior?
  28. Switch passed type from template
  29. Obtain container type from (its) iterator type in C++ (STL)
  30. How does std::forward receive the correct argument?

Leave a Comment