Choose multiple template based on multiple run-time string in C++

Question

My question here is similar to this post expect that I have more than one template argument and string. Thus, the setup is

class base_class; // no template args

template<typename T, typename U, typename V>
class child_class : public base_class;

I have a limited number of implemented types for T, U and V which I want to select at runtime given three strings. So as the question in cited post, I could do something like

std::unique_ptr<base_class> choose_arg1(
    std::string T_str, std::string U_str, std::string v_str){
  if(T_str == "int"){
    return(choose_arg2<int>(U_str, V_str));

  } else if(T_str == "char"){
    return(choose_arg2<char>(U_str, V_str));

  } // ...
}

template<typename T>
std::unique_ptr<base_class> choose_arg2(std::string U_str, std::string v_str){
  if(U_str == "int"){
    return(choose_arg3<T, int>(V_str));

  } else if(U_str == "char"){
    return(choose_arg3<T, char>(V_str));

  } // ...
}

template<typename T, typename U>
std::unique_ptr<base_class> choose_arg3(std::string v_str){
  if(v_str == "int"){
    return(std::make_unique<child_class<T, U, int>>());

  } else if(v_str == "char"){
    return(std::make_unique<child_class<T, U, char>>());

  } // ...
}

but is there a better way? I have less than 5^3 combination for the record.

Should this be portable or are you just playing around with your computer and a particular compiler (GCC...)? — Julius, Oct 24 '17 at 13:51
You could have a static `std::map(std::string const &)>>` in each function and then search for the argument string in it. — AVH, Oct 24 '17 at 14:58
@Darhuuk so like [this](https://stackoverflow.com/a/38644618/5861244) answer in the post I link to in my question? — Benjamin Christoffersen, Oct 24 '17 at 15:15
@BenjaminChristoffersen Ah yes. Seems like I wasted my time typing up an example for your code :). — AVH, Oct 24 '17 at 15:15

score 3 · Answer 1 · answered Oct 24 '17 at 15:41

I suggest to develop a template helper struct with a couple of static func() methods

template <typename ... Ts>
struct choose_args_h
 {
   using retT = std::unique_ptr<base_class>;

   template <typename ... Args>
   static retT func (std::string const & s, Args const & ... args)
    {
      if ( s == "int" )
         return choose_args_h<Ts..., int>::func(args...);
      else if ( s == "char" )
         return choose_args_h<Ts..., char>::func(args...);
      // else ...
    }

   static retT func ()
    { return std::make_unique<child_class<Ts...>>(); }
 };

so you can write a choose_args() func simply as follows

template <typename ... Args>
std::unique_ptr<base_class> choose_args (Args const & ... args)
 { return choose_args_h<>::func(args...); }

The following is a full working example

#include <string>
#include <memory>

class base_class
 { };

template <typename, typename, typename>
class child_class : public base_class
 { };

template <typename ... Ts>
struct choose_args_h
 {
   using retT = std::unique_ptr<base_class>;

   template <typename ... Args>
   static retT func (std::string const & s, Args const & ... args)
    {
      if ( s == "int" )
         return choose_args_h<Ts..., int>::func(args...);
      else if ( s == "char" )
         return choose_args_h<Ts..., char>::func(args...);
      // else ...
    }

   static retT func ()
    { return std::make_unique<child_class<Ts...>>(); }
 };

template <typename ... Args>
std::unique_ptr<base_class> choose_args (Args const & ... args)
 { return choose_args_h<>::func(args...); }

int main ()
 {
   auto p0 = choose_args("int", "char", "int");
   auto p1 = choose_args("int", "char", "char");
 }

Unless there's specific restrictions on which type is allowed for each template argument, I consider this the much nicer version of what I suggested :). — AVH, Oct 24 '17 at 15:49
@BenjaminChristoffersen - sorry: from your example I've understood that there is the same list of string argument and the same choose of templates in every position; if it isn't, I suspect that your example -- a function for every level -- it's a good solution; not necessarily the best but a good one. — max66, Oct 24 '17 at 16:16
@max66 I Agree, my example was not clear in that regard. I should have been more specific. — Benjamin Christoffersen, Oct 24 '17 at 21:19

Julius · Accepted Answer · 2017-10-24T23:28:32.760

Shown in this post is a C++17 solution with compile-time configuration of the allowed types and corresponding keys via the type Argmaps. The lookup is done by a compile-time loop.

C++11 does not support generic lambdas which are required for the compile-time loops used here. Instead, one could perform the lookup by template meta-programming with the "indices trick" (as in this online demo), but that feels too complicated and I prefer the std::map approach anyway. Note that my linked C++11 attempt could call the constructor twice if the keys are not unique.

#include <iostream>
#include <memory>
#include <string>

#include "loop.hpp"

template<class... Ts> struct Types {
  static constexpr size_t size = sizeof...(Ts);

  template<size_t i>
  using At = std::tuple_element_t<i, std::tuple<Ts...>>;
};

template<class... Ts> constexpr Types<Ts...> to_types(Ts...) { return {}; }

template<auto... cs> struct Str {
  operator std::string() const {
    constexpr auto list = std::initializer_list<char>{cs...};
    return std::string{list.begin(), list.end()};
  }
};

template<class Char, Char... cs>
constexpr auto operator""_c() {
  return Str<cs...>{};
}

//////////////////////////////////////////////////////////////////////////////

struct Base {
  virtual void identify() const = 0;
};

template<class... Ts>
struct Derived : Base {
  virtual void identify() const override {
    std::cout << __PRETTY_FUNCTION__ << std::endl;
  }
};

using Ptr = std::unique_ptr<Base>;

//////////////////////////////////////////////////////////////////////////////

template<class Argmaps, class Args=Types<>>
struct choose_impl;

template<class Map0, class... Maps, class... Args>
struct choose_impl<Types<Map0, Maps...>, Types<Args...>> {
  static constexpr size_t pos = sizeof...(Args);

  template<class S0, class... Ss>
  static Ptr get(S0 s0, Ss... ss) {
    Ptr ret{nullptr};

    using namespace Loop;
    loop(less<Map0::size>, [&] (auto i) {
      using Argmapping = typename Map0::template At<i>;
      using Key = typename Argmapping::template At<0>;
      using Arg = typename Argmapping::template At<1>;
      using Recursion = choose_impl<Types<Maps...>, Types<Args..., Arg>>;
      if(std::string(Key{}) == s0) ret = Recursion::get(ss...);
    });

    if(!ret) {
      std::cerr << "NOT MAPPED AT POS " << pos << ": " << s0 << std::endl;
      std::terminate();
    }

    return ret;
  }
};

template<class... Args>// all Args are resolved
struct choose_impl<Types<>, Types<Args...>> {
  static Ptr get() {
    return std::make_unique<Derived<Args...>>();
  }
};

template<class Argmaps, class... Ss>
Ptr choose(Ss... ss) {
  static_assert(Argmaps::size == sizeof...(Ss));
  return choose_impl<Argmaps>::get(std::string(ss)...);
}

template<class V, class K>
auto make_argmapping(K) {
  return Types<K, V>{};
}

//////////////////////////////////////////////////////////////////////////////

int main() {
  using Argmaps = decltype(
    to_types(
      to_types(// first template parameter
        make_argmapping<int>("int"_c),
        make_argmapping<char>("char"_c),
        make_argmapping<bool>("bool"_c)
      ),
      to_types(// ... second ...
        make_argmapping<double>("double"_c),
        make_argmapping<long>("long"_c)
      ),
      to_types(// ... third
        make_argmapping<bool>("bool"_c)
      )
    )
  );

  choose<Argmaps>("int", "double", "bool")->identify();
  choose<Argmaps>("int", "long", "bool")->identify();
  choose<Argmaps>("char", "double", "bool")->identify();
  choose<Argmaps>("char", "long", "bool")->identify();
  choose<Argmaps>("bool", "double", "bool")->identify();
  choose<Argmaps>("bool", "long", "bool")->identify();

// bad choice:
  choose<Argmaps>("int", "int", "bool")->identify();

  return 0;
}

loop.hpp from this unread answer:

#ifndef LOOP_HPP
#define LOOP_HPP

namespace Loop {

template<auto v> using Val = std::integral_constant<decltype(v), v>;

template<auto i> struct From : Val<i> {};
template<auto i> static constexpr From<i> from{};

template<auto i> struct Less : Val<i> {};
template<auto i> static constexpr Less<i> less{};

// `to<i>` implies `less<i+1>`
template<auto i> struct To : Less<i+decltype(i)(1)> {};
template<auto i> static constexpr To<i> to{};

template<auto i> struct By : Val<i> {};
template<auto i> static constexpr By<i> by{};

template<auto i, auto N, auto delta, class F>
constexpr void loop(From<i>, Less<N>, By<delta>, F f) noexcept {
  if constexpr(i<N) {
    f(Val<i>{});
    loop(from<i+delta>, less<N>, by<delta>, f);
  }
}

// overload with two arguments (defaulting `by<1>`)
template<auto i, auto N, class F>
constexpr void loop(From<i>, Less<N>, F f) noexcept {
  loop(from<i>, less<N>, by<decltype(i)(1)>, f);
}

// overload with two arguments (defaulting `from<0>`)
template<auto N, auto delta, class F>
constexpr void loop(Less<N>, By<delta>, F f) noexcept {
  loop(from<decltype(N)(0)>, less<N>, by<delta>, f);
}

// overload with one argument (defaulting `from<0>`, `by<1>`)
template<auto N, class F>
constexpr void loop(Less<N>, F f) noexcept {
  using Ind = decltype(N);
  loop(from<Ind(0)>, less<N>, by<Ind(1)>, f);
}

} // namespace Loop

#endif

http://coliru.stacked-crooked.com/a/5ce61617497c3bbe

Looks neat. Though, I need it the code to be able to build with compilers that only has support for C++11. Will that be possible? — Benjamin Christoffersen, Oct 24 '17 at 21:17

score 2 · Answer 3 · answered Oct 24 '17 at 15:18

As I noted in my comment, you could use a static map of string to function.

For your example code (slightly simplified to 2 template parameters to make it a little shorter), this would become:

#include <iostream>
#include <string>
#include <map>
#include <functional>
#include <memory>

class base_class { }; // no template args

template<typename T, typename U>
class child_class : public base_class { };

using ptr_type = std::unique_ptr<base_class>;

// Declarations
std::unique_ptr<base_class> choose_arg1 (std::string const & T_str,
    std::string const & U_str);

template<typename T>
std::unique_ptr<base_class> choose_arg2 (std::string const & U_str);

// Definitions
std::unique_ptr<base_class> choose_arg1 (std::string const & T_str,
    std::string const & U_str) {
  using function_type = std::function<ptr_type(std::string const &)>;
  using map_type = std::map<std::string, function_type>;

  static const map_type ptrMap = {
    {"int",  choose_arg2<int>  },
    {"char", choose_arg2<char> }
  };

  auto ptrIter = ptrMap.find(T_str);
  return (ptrIter != ptrMap.end()) ? ptrIter->second(U_str) : nullptr;
}

template<typename T>
std::unique_ptr<base_class> choose_arg2 (std::string const & U_str) {
  using function_type = std::function<ptr_type()>;
  using map_type = std::map<std::string, function_type>;

  static const map_type ptrMap = {
    {"int",  []{ return std::make_unique<child_class<T, int>>();  } },
    {"char", []{ return std::make_unique<child_class<T, char>>(); } }
  };

  auto ptrIter = ptrMap.find(U_str);
  return (ptrIter != ptrMap.end()) ? ptrIter->second() : nullptr;
}

int main () {
  std::cout << typeid(choose_arg1("int", "char")).name() << "\n";
  std::cout << "[Done]\n";
}

Very nice. Short meta question: Is it good practice to delete my own answer if I prefer yours? — Julius, Oct 24 '17 at 15:21
@Julius Thanks! I'd leave your answer. I'd like to take a look at it later tonight :). — AVH, Oct 24 '17 at 15:31
It is not clear to me what I win with the approach rather than `if`-`else if` approach I suggest? — Benjamin Christoffersen, Oct 24 '17 at 21:23
This approach with an `std::map` looks very powerful to me. I guess it can be applied to create a configurable/variadic version like [mine](https://stackoverflow.com/a/46914203/2615118), but without those ugly types and more readable. — Julius, Oct 24 '17 at 21:28
@BenjaminChristoffersen To me the advantage versus the `if-else` approach is that you don't have to repeat the `if`-statement all the time and have all possible choices clearly in 1 location (the constructor of the static map). In other words, I find it much more readable. — AVH, Oct 24 '17 at 23:47

Choose multiple template based on multiple run-time string in C++

3 Answers3