enable_if в членах функций для пустоты и наследования

Создавая экземпляр Test<void>, вы также создавали экземпляры объявлений всех его функций-членов. Это просто базовая реализация. Какие декларации это дает вам? Что-то вроде этого:

void execute(void);
void execute(<ill-formed> t);

Если вы ожидали, что SFINAE молча удалит неправильно сформированную перегрузку, вам нужно помнить, что S означает «замещение». Подстановка аргументов шаблона в параметры (члена) шаблона функции. Ни один из execute не является шаблоном функции-члена. Обе они являются обычными функциями-членами специализации шаблона.

Вы можете исправить это несколькими способами. Одним из способов было бы сделать эти два шаблона, правильно выполнить SFINAE и позволить разрешению перегрузки взять вас оттуда. @YSC уже показывает, как это сделать.

Другой способ — использовать вспомогательный шаблон. Таким образом, вы получаете свою первоначальную цель, чтобы одна функция-член существовала в любой момент времени.

template<typename T>
struct TestBase {
  void execute(T t) { }
};

template<>
struct TestBase<void> {
  void execute() { }
};

template<class T>
struct Test : private TestBase<T> {
  using TestBase<T>::execute;
};

Вы можете выбрать то, что лучше всего подходит для ваших нужд.

Чтобы исправить ваше редактирование. Я думаю, что второй подход действительно лучше соответствует вашим потребностям.

template<typename T>
struct TestBase : Base {
  void execute(T t) override { }
};

template<>
struct TestBase<void> : Base {
  void execute() override { }
};

TestBase — это посредник, который выполняет то, что вам нужно.

Примечание: этот ответ полезен для предыдущего редактирования вопроса. Недавнее редактирование радикально изменило вопрос, и этот ответ больше не является адекватным.

Поскольку execute не является шаблонной функцией, не может быть задействована функция SFINAE. Действительно, всякий раз, когда создается экземпляр Test<void>, создаются обе версии execute, что приводит к ошибке, которая не является ошибкой вывода шаблона.

Вам нужен шаблон функции (пусть вызовите параметр шаблона U), чтобы воспользоваться преимуществами SFINAE; и поскольку вам нужно использовать аргумент шаблона того же типа Test (T), вы можете указать аргумент по умолчанию U = T):

Решение:

template<class T>
struct Test
{
    template<class U = T>
    std::enable_if_t<std::is_void_v<U>> execute()
    { std::cout << "is_void\n"; }

    template<class U = T>
    std::enable_if_t<!std::is_void_v<U>> execute()
    { std::cout << "!is_void\n"; }
};

Текущая демонстрация

Есть и другой вариант, менее элегантный, чем тот, который использует CRTP. Он заключается в выборе в теле переопределения, куда его направить к базовой реализации или предоставляет новую реализацию функции.

Если бы вы использовали С++ 17, это было бы просто благодаря if constexpr. В С++ 11 альтернативой является использование отправки тегов:

template<class T>
struct Test : Base
  {
    void execute()
      {
      void do_execute(std::integral_constant<bool,std::is_void<T>::value>{});
      }

    void execute(int t)
      {
      void do_execute(std::integral_constant<bool,!std::is_void<T>::value>{}, t);
      }
  private:
  void do_execute(std::integral_constant<bool,true>){
       /*implementation*/
       }
  void do_execute(std::integral_constant<bool,false>){
       Base::execute();//Call directly the base function execute.
                       //Such call does not involve the devirtualization
                       //process.
       }
  void do_execute(std::integral_constant<bool,true>,int t){
       /*implementation*/
       }
  void do_execute(std::integral_constant<bool,false>,int t){
       Base::execute(t);//Call directly the base function execute.
                        //Such call does not involve the devirtualization
                        //process.
       }
  };

С C++17 if constexpr это может выглядеть более элегантно, чем решение CRTP:

template<class T>
struct Test : Base
  {
    void execute(){
      if constexpr (is_void_v<T>){
         Base::execute();
         }
      else{
        /* implementation */
        }
      }

    void execute(int t){
      if constexpr (!is_void_v<T>){
         Base::execute(t);
         }
      else{
        /* implementation */
        }
      }
  };

Вы можете инкапсулировать различные перегрузки execute в набор связанных вспомогательных классов, примерно так:

template <class T>
struct TestHelper : Base
{
  void execute(int) override {}
};

template <>
struct TestHelper<void> : Base
{
  void execute() override {}
};


template <class T>
struct Test : TestHelper<T>
{
  // Other Test stuff here
};

Если реализация execute на самом деле зависит от «Другого тестового материала», который должен быть разделен между ними, вы также можете использовать CRTP:

template <class T, class Self>
struct TestHelper : Base
{
  void execute(int) override
  {
    Self& self = static_cast<Self&>(*this);
    // Now access all members through `self.` instead of directly
  }
};

template <class Self>
struct TestHelper<void, self> : Base
{
  void execute() override
  {
    Self& self = static_cast<Self&>(*this);
    // Now access all members through `self.` instead of directly
  }
};

template <class T>
struct Test : TestHelper<T, Test>
{
  // Other Test stuff here
};