Creating an instance of a specialized class depending on run-time arguments - c++

Question

Here's the code which demonstrates the idea:
struct A
{
};
struct B
{
};
template<typename T1, typename T2>
struct Specific
{
T1 t1;
T2 t2;
void DoSomething() {}
};
template<typename T1, typename T2>
Specific<T1, T2> create_specific()
{
return Specific<T1, T2>();
}
void my_func(int type1, int type2)
{
if (type1 == 1 && type2 == 1)
{
auto specific = create_specific<A, A>();
specific.DoSomething();
}
else if (type1 == 1 && type2 == 2)
{
auto specific = create_specific<A, B>();
specific.DoSomething();
}
else if (type1 == 2 && type2 == 1)
{
auto specific = create_specific<B, A>();
specific.DoSomething();
}
else if (type1 == 2 && type2 == 2)
{
auto specific = create_specific<B, B>();
specific.DoSomething();
}
}
So my_func arguments control which type it will use to DoSomething.
The problem with this approach is that the number of if conditions will grow exponentially. I'm looking for a way to have the compiler do this for me. It would be nice if I could split the logic for every type slot:
if (type1 == 1)
{
create_specific1<A>(...);
}
....
if (type2 == 2)
{
create_specific2<B>(...);
}
Is it at all possible?
UPDATE
Is there any way to implement the template magic in C++11, in particular in Visual C++ 2013?

Answer 1

One way is to use a lookup table like this.
void (*arr[2][2])() =
{
[] { create_specific<A, A>().DoSomething(); },
[] { create_specific<A, B>().DoSomething(); },
[] { create_specific<B, A>().DoSomething(); },
[] { create_specific<B, B>().DoSomething(); }
};
arr[type1-1][type2-1]();
You can also let the compiler produce it for you. This works with two types:
template <std::size_t...> struct index_list {using type = index_list;};
template <typename, typename> struct concat;
template <std::size_t... i, std::size_t... j> struct concat<index_list<i...>, index_list<j...>> : index_list<i..., j...> {};
// inefficient linear recursive method:
template <std::size_t N>
struct make_index_list : concat<typename make_index_list<N-1>::type, index_list<N>> {};
template <>
struct make_index_list<0> : index_list<0> {};
template <typename A, typename B = A,
typename = typename make_index_list<std::tuple_size<A>::value
* std::tuple_size<B>::value - 1>::type>
class create_lookup;
template <typename ... First, typename... Second, std::size_t... indices>
class create_lookup<std::tuple<First...>, std::tuple<Second...>, index_list<indices...>>
{
template <typename T, typename U>
static void work()
{
create_specific<T, U>().DoSomething();
}
public:
static constexpr void (*arr[sizeof...(First)][sizeof...(Second)])() =
{
work< typename std::tuple_element<indices / sizeof...(First), std::tuple<First...>>::type,
typename std::tuple_element<indices % sizeof...(Second), std::tuple<Second...>>::type >...
};
};
template <typename ... F, typename... S, std::size_t... I>
constexpr void (*create_lookup<std::tuple<F...>, std::tuple<S...>, index_list<I...>>::arr[sizeof...(F)][sizeof...(S)])();
int main()
{
auto arr = create_lookup<std::tuple<A, B>>::arr;
for (int i = 0; i < 2; ++i)
for (int j = 0; j < 2; ++j)
{
std::cout << i << ' ' << j << ": ";
arr[i][j]();
}
}
Since C++14 you could also use a lambda as the expansion pattern, instead of a function template (work). And std::make_index_sequence, and std::tuple_element_t ... ;)
Setting the DoSomething-function to
void DoSomething()
{
std::cout << typeid(T1).name() << ' ' << typeid(T2).name() << '\n';
}
yields the following output:
0 0: A A
0 1: A B
1 0: B A
1 1: B B
Generazalization to more types
This code works with an arbitrary amount of concatenations, specified by the template parameter depth. Example is included, using GCC's demangle function.
#include <iostream>
#include <iomanip>
#include <typeinfo>
#include <tuple>
#include <cxxabi.h>
template<typename... T>
struct Specific
{
void DoSomething()
{
int status;
std::initializer_list<bool> { std::cout << abi::__cxa_demangle(typeid(T).name(), 0, 0, &status) << ' '... };
//std::initializer_list<bool> { std::cout << typeid(T).name() << ' '... };
std::cout << '\n';
}
};
template<typename... T>
Specific<T...> create_specific()
{ return {}; }
template <std::size_t...> struct index_list {using type = index_list;};
template <typename, typename> struct concat;
template <std::size_t... i, std::size_t... j> struct concat<index_list<i...>, index_list<j...>> : index_list<i..., j...> {};
template <std::size_t N>
struct make_index_list : concat<typename make_index_list<N-1>::type, index_list<N>> {};
template <>
struct make_index_list<0> : index_list<0> {};
constexpr std::uintmax_t ipow( std::uintmax_t base, unsigned exp )
{
return exp == 0? 1 : base*ipow(base, exp-1);
}
template <typename T, std::size_t len, std::size_t dim>
struct construct_array
{
using type = typename construct_array<T, len, dim-1>::type[len];
};
template <typename T, std::size_t len>
struct construct_array<T, len, 1>
{
using type = T[len];
};
template <std::size_t depth,
typename A,
typename = typename make_index_list<ipow(std::tuple_size<A>::value, depth)- 1>::type>
class create_lookup;
template <std::size_t depth, typename ... First, std::size_t... indices>
class create_lookup<depth, std::tuple<First...>, index_list<indices...>>
{
template <typename... Args>
static void work()
{
create_specific<Args...>().DoSomething();
}
static constexpr auto length = sizeof...(First);
template <std::size_t index, typename = typename make_index_list<depth-1>::type>
struct get_ptr;
template <std::size_t index, std::size_t ... type_indices>
struct get_ptr<index, index_list<type_indices...>>
{
static constexpr auto value =
work< typename std::tuple_element<index / ipow(length, depth-type_indices-1) % length, std::tuple<First...>>::type... >;
};
public:
static constexpr typename construct_array<void(*)(), length, depth>::type arr
{
get_ptr<indices>::value...
};
};
template <std::size_t depth, typename ... F, std::size_t... I>
constexpr typename construct_array<void(*)(), create_lookup<depth, std::tuple<F...>, index_list<I...>>::length, depth>::type
create_lookup<depth, std::tuple<F...>, index_list<I...>>::arr;
struct A {};
struct B {};
struct C {};
int main()
{
auto arr = create_lookup<3, std::tuple<A, B, C>>::arr;
for (int i = 0; i < 3; ++i)
for (int j = 0; j < 3; ++j)
for (int k = 0; k < 3; ++k)
{
std::cout << i << ' ' << j << ' ' << k << ": ";
arr[i][j][k]();
}
}
The same code but without constexpr can be found here.