Type grouped Explicit Instantiation of templates

Question

If I have a template class with overloaded template member functions(using SFINAE) like:

template <typename T>
struct Foo{
    Foo(T elem);

    template <typename U = T>
    auto get() -> std::enable_if_t<std::is_same_v<U, int>, U>;
    template <typename U = T>
    auto get() -> std::enable_if_t<std::is_same_v<U, bool>, U>;
    T elem_;
};

Now in my CPP file, I must define and explicitly instantiate:

template class Foo<int>;
template int Foo<int>::get<int>();
template class Foo<bool>;
template bool Foo<bool>::get<bool>();
// For all types...T, there will be two statements.

What are different possible ways to do a grouped instantiation by type - something like:

GroupedFooInit<int>(); // does both Foo<int> and Foo<int>::get<int>
GroupedFooInit<bool>(); // similar
.. and so on.

Given that I'm bounded to use C++14, 2 workarounds I could come up with but didnt want/like:
1. Macros: Possible, but would like to strongly avoid.
2. Definition in header, no explicit instantiation needed: Possible, but im working on a huge repo where the file Im dealing with is pretty much included everywhere - so my build times are huge if I go this route for even minor changes.

Link to Code Snippet

So you are using SFINAE here just to choose between one of two overloads depending on `T` alone? — StoryTeller - Unslander Monica, Jan 20 '19 at 07:50
Can not you use `if constexpr` in the body of a unique `get` function? — Oliv, Jan 20 '19 at 07:51
@StoryTeller yes - Edit: It would best if this could be generalized i.e. for N different overloads — tangy, Jan 20 '19 at 07:59
@Oliv stuck in C++14 land, adding the clarification in the question — tangy, Jan 20 '19 at 07:59
Mmm. My suggestion would have been not to go the SFINAE route at all. Then you can in fact have what you want, simplicity *and* external definition. But if your condition on `T` is not quite what it is in this example, it probably isn't appropriate, — StoryTeller - Unslander Monica, Jan 20 '19 at 08:04
Yea the condition on T isnt very simple in the actual code - I've oversimplified a few aspects here to keep the example minimal. — tangy, Jan 20 '19 at 08:07

Oliv · Accepted Answer · 2019-01-20T08:31:57.073

You could solve the problem by adding a layer:

template <typename T>
struct Foo{
  Foo(T elem);

  T elem_;

  T get(){
     return do_get<T>();
     }

  private:

  template <typename U = T>
  auto do_get() -> std::enable_if_t<std::is_same<U, int>::value, U>;

  template <typename U = T>
  auto do_get() -> std::enable_if_t<std::is_same<U, bool>::value, U>;
   };
//If definitions for the do_get functions are provided before these
//explicit template instantiation definitions, the compiler will certainly
//inline those definitions.
template class Foo<int>;
template class Foo<bool>;

Type grouped Explicit Instantiation of templates

1 Answers1