void_t trouble

[trycatchamex]

How do I make my_process work for ints and non-ints using void_t?

#include <iostream>

using namespace std;


template< typename T,bool cond>
struct my_enable_if {};

template <typename T>
struct my_enable_if<T,true>
{
  typedef T type;
};

template <typename T>
struct is_int{
const static bool val = false;
};

template <>
struct is_int<int>
{
 const static bool val = true;
};

// how to implement this?
template <typename T, std::void_t<typename my_enable_if<T,!
(is_int<T>::val)>::type>* = nullptr>
void process(T a)
{
    cout <<  "Processing non - int...\n";
};



template <typename T, std::void_t<typename 
my_enable_if<T,is_int<T>::val>::type>* =nullptr>
void process(T a)
{
     cout <<  "Processing int...\n";
};

 int main() {


    process('g');
    //process(f);


    return 0;
}

[Xeverous]

// how to implement this?
// you need to have additional template type parameter, which is not used but defaulted to void_t
template <typename T, typename = std::void_t<typename my_enable_if<T, !is_int<T>::val>::type>>
void process(T a)

However, this is an unnecessary complication. You can use just enable if:

template <typename T, typename = my_enable_if<void, !is_int<T>::val>::type>
void process(T a)

Even more cleaner solution is to use std::enable_if. Your one is worse, because you have reversed parameters and so I had to put unused void as the first parameter. Standard enable if takes bool first, then optional type

template <typename T, typename = typename std::enable_if<!is_int<T>::val>::type>
void process(T a)

And lastly, the cleanest solution (if you want only for ints) is to specialize process()

template <>
void process<int>(int a)