С++ с использованием объявления для пакета параметров

Проблема с подходом Jarod42 заключается в том, что вы меняете вид разрешения перегрузки - как только вы делаете все шаблоном, все становится точное совпадение, и вы больше не сможете различать несколько жизнеспособных кандидатов:

struct A { void DoSomething(int); };
struct B { void DoSomething(double); };
SomeClass<A, B>().DoSomething(42); // error ambiguous

Единственный способ сохранить разрешение перегрузки — использовать наследование.

Ключевым моментом является завершение того, что начал ecatmur. Но как выглядит HasDoSomething? Подход в ссылке работает только при наличии одного, не перегруженного, не шаблонного. Но мы можем сделать лучше. Мы можем использовать тот же механизм, чтобы определить, существует ли DoSomething, который требует using для начала: имена из разных областей не перегружаются.

Итак, мы вводим новый базовый класс, который имеет DoSomething, который никогда не будет по-настоящему выбран, и мы делаем это, создавая свой собственный явный тип тега, который мы единственные, кто когда-либо будет создавать. За неимением лучшего имени, я назову его в честь моей собаки Вести:

struct westie_tag { explicit westie_tag() = default; };
inline constexpr westie_tag westie{};
template <typename T> struct Fallback { void DoSomething(westie_tag, ...); };

И сделайте его вариативным для хорошей меры, просто чтобы сделать его как можно меньше. Но на самом деле это не имеет значения. Теперь, если мы введем новый тип, например:

template <typename T> struct Hybrid : Fallback<T>, T { };

Затем мы можем вызвать DoSomething() на гибриде именно тогда, когда T нет перегрузки DoSomething — любого типа. Это:

template <typename T, typename=void>
struct HasDoSomething : std::true_type { };
template <typename T>
struct HasDoSomething<T, std::void_t<decltype(std::declval<Hybrid<T>>().DoSomething(westie))>>
    : std::false_type
{ };

Обратите внимание, что обычно в этих трейтах первичным является false, а специализация — true — здесь все наоборот. Ключевое различие между этим ответом и ответом ecatmur заключается в том, что перегрузка резервного варианта должна быть каким-то образом вызвана - и использовать эту возможность для ее проверки - просто она не будет фактически вызываться для любого типа, который пользователь будет фактически использовать.

Проверка таким образом позволяет нам правильно определить, что:

struct C {
    void DoSomething(int);
    void DoSomething(int, int);
};

действительно удовлетворяет HasDoSomething.

А затем используем тот же метод, который показал ecatmur:

template <typename T>
using pick_base = std::conditional_t<
    HasDoSomething<T>::value,
    T,
    Fallback<T>>;

template<typename... Bases>
class SomeClass : public Fallback<Bases>..., public Bases...
{
public: 
  using pick_base<Bases>::DoSomething...;

  void DoSomething();
};

И это работает независимо от того, как выглядят все перегрузки Bases DoSomething, и правильно выполняет разрешение перегрузок в первом упомянутом мной случае.

Демо

Как насчет условного использования запасного варианта?

Создайте не вызываемые реализации каждого метода:

template<class>
struct Fallback {
    template<class..., class> void DoSomething();
};

Наследовать от Fallback один раз для каждого базового класса:

class SomeClass : private Fallback<Bases>..., public Bases...

Затем условно извлеките каждый метод либо из базового класса, либо из его соответствующего запасного варианта:

using std::conditional_t<HasDoSomething<Bases>::value, Bases, Fallback<Bases>>::DoSomething...;

Пример.

Вы можете добавить оболочку, которая обрабатывает основные случаи, пересылая вместо using:

template <typename T>
struct Wrapper : T
{
    template <typename ... Ts, typename Base = T>
    auto DoSomething(Ts&&... args) const
    -> decltype(Base::DoSomething(std::forward<Ts>(args)...))
    {
        return Base::DoSomething(std::forward<Ts>(args)...);
    }

    template <typename ... Ts, typename Base = T>
    auto DoSomething(Ts&&... args)
    -> decltype(Base::DoSomething(std::forward<Ts>(args)...))
    {
        return Base::DoSomething(std::forward<Ts>(args)...);
    }

    // You might fix missing noexcept specification
    // You might add missing combination volatile/reference/C-elipsis version.
    // And also special template versions with non deducible template parameter...
};

template <typename... Bases>
class SomeClass : public Wrapper<Bases>...
{
public: 
  using Wrapper<Bases>::DoSomething...; // All wrappers have those methods,
                                        // even if SFINAEd

  void DoSomething(){ /*..*/ }
};

Демо

Как заметил Барри, есть и другие недостатки, поскольку изменилось разрешение перегрузки, что сделало некоторые вызовы неоднозначными...

Примечание. Я предложил это решение, так как не знал, как создать правильные трейты для обнаружения присутствия DoSomething во всех случаях (в основном проблема связана с перегрузками). Барри решил это, так что у вас есть лучшая альтернатива.

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

#include<type_traits>

template<class,class> struct cons;  // not defined
template<class ...TT> struct pack;  // not defined

namespace detail {
  template<template<class> class,class,class,class>
  struct sift;
  template<template<class> class P,class ...TT,class ...FF>
  struct sift<P,pack<>,pack<TT...>,pack<FF...>>
  {using type=cons<pack<TT...>,pack<FF...>>;};
  template<template<class> class P,class I,class ...II,
           class ...TT,class ...FF>
  struct sift<P,pack<I,II...>,pack<TT...>,pack<FF...>> :
    sift<P,pack<II...>,
         std::conditional_t<P<I>::value,pack<TT...,I>,pack<TT...>>,
         std::conditional_t<P<I>::value,pack<FF...>,pack<FF...,I>>> {};

  template<class,class=void> struct has_something : std::false_type {};
  template<class T>
  struct has_something<T,decltype(void(&T::DoSomething))> :
    std::true_type {};
}

template<template<class> class P,class ...TT>
using sift_t=typename detail::sift<P,pack<TT...>,pack<>,pack<>>::type;

Затем разложите результат и наследуйте от отдельных классов:

template<class> struct C;
template<class ...MM,class ...OO>  // have Method, Others
struct C<cons<pack<MM...>,pack<OO...>>> : MM...,OO... {
  using MM::DoSomething...;
  void DoSomething();
};

template<class T> using has_something=detail::has_something<T>;

template<class ...TT> using C_for=C<sift_t<has_something,TT...>>;

Обратите внимание, что has_something здесь поддерживает только неперегруженные методы (на базовый класс) для простоты; см. ответ Барри для обобщения этого.