C ++ перегрузка обобщенной функции с помощью SFINAE

Question

Я пытаюсь написать простой протокол сериализации.send для типа контейнера должен вызывать send для каждого из элементов (которые сами могут быть типами контейнера).

Однако я не могу понять, как это сделать.Я написал три функции, каждая из которых работает индивидуально, но я не могу понять, как заставить C ++ выбирать и отправлять соответствующую функцию.Как мне это сделать?

В нынешнем виде clang говорит, что я не могу переопределить send с такой же подписью (даже не для SFINAE).

Яиспользуя C ++ 17, но я не могу использовать внешнюю библиотеку, такую ​​как boost.[править] Это для личного вызова.Я хочу знать, как это сделать с ванильным C ++.В конце концов, эту библиотеку кто-то должен был написать на vanilla C ++, верно?[/ edit]

#include <vector>
#include <utility>
#include <iostream>
#include <type_traits>

template <class pair_t>
std::void_t<typename pair_t::first_type, typename pair_t::second_type>
send(pair_t pair) {
    using first_t = typename pair_t::first_type;
    using second_t = typename pair_t::second_type;

    send<first_t>(std::get<0>(pair));
    send<second_t>(std::get<1>(pair));
}

template <typename list_t>
std::void_t<typename list_t::value_type, typename list_t::size_type>
send(list_t list) {
    using value_t = typename list_t::value_type;

    for (const value_t& elem : list) {
        send<value_t>(elem);
    }
}

template <typename int_t>
void
send(typename std::enable_if<std::is_integral<int_t>::value, int_t>::type val) {
    std::cout << "Sending integral val: " << val << std::endl;
}

int obj0 = 1;
std::vector<int> obj1;
std::pair<int, int> obj2;
std::vector<std::pair<int,int>> obj3;
int main() {
    // send<int>(obj0);
    // send(obj1);
    // send(obj2);
    // send(obj3);
}

Answer 1

Вы можете использовать специализацию шаблона:

template <typename T> void send(const T&);

namespace detail {
  template <typename T> struct Send;  // primary template

  template <typename T> struct Send<std::vector<T>> {  // specialization for vector
    static void send(const std::vector<T>& v) {
      for (const auto e : v) ::send(e);
    }
  };

  template <typename T, typename U> struct Send<std::pair<T, U>> {  // for pair
    static void send(const std::pair<T, U>& p) {
      ::send(p.first); ::send(p.second);
    }
  };

  template <> struct Send<int> {  // for int
    static void send(int i) { std::cout << i; }
  };
}

template <typename T> void send(const T& arg) { detail::Send<T>::send(arg); }

int main() {
  int i = 0;
  std::vector<int> vi = { 1, 2, 3 };
  std::pair<int, int> pi = { 4, 5 };
  std::vector<std::pair<int, int>> vpi = { { 7, 8 }, { 9, 0 } };
  send(i);
  send(vi);
  send(pi);
  send(vpi);
}

Демонстрационная версия: https://wandbox.org/permlink/cQNpsgSFYmiurqRT

Обратите внимание, что это решение требует специализаций для всех типов контейнеров, которые вы хотите поддерживать (отличается отчто использует эту реализацию для любого типа, который вложил value_type и size_type).

---

Или вы также можете использовать SFINAE:

template <typename T> struct is_vector : std::false_type { };
template <typename T> struct is_vector<std::vector<T>> : std::true_type { };

template <typename T> struct is_pair : std::false_type { };
template <typename T, typename U> struct is_pair<std::pair<T, U>> : std::true_type { };

template <typename T> void send(T i, std::enable_if_t<std::is_integral_v<T>, int> = 0) {
  std::cout << i;
}

template <typename T> void send(const T& p, std::enable_if_t<is_pair<T>::value, int> = 0) {
  send(p.first); send(p.second);
}

template <typename T> void send(const T& v, std::enable_if_t<is_vector<T>::value, int> = 0) {
  for (const auto & e : v) send(e);
}

... // same main

---

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

template <typename T> struct has_value_type {
  using yes = char[1]; using no = char[2];
  template <typename C> static constexpr yes& test(typename C::value_type*);
  template <typename> static constexpr no& test(...);
  static constexpr bool value = sizeof(test<T>(nullptr)) == sizeof(yes);
};   

... // similarly: has_size_type, has_first_type, and has_second_type

template <typename T> void send(T i, std::enable_if_t<std::is_integral_v<T>, int> = 0) {
  std::cout << i;
}

template <typename T> void send(const T& p, std::enable_if_t<has_first_type<T>::value && has_second_type<T>::value, int> = 0) {
  send(p.first); send(p.second);
}

template <typename T> void send(const T& v, std::enable_if_t<has_value_type<T>::value && has_size_type<T>::value, int> = 0) {
  for (const auto & e : v) send(e);
}

... // same main

Демонстрационная версия: https://wandbox.org/permlink/qD7vp2ebzFaR15qf

Answer 2

Самый простой способ решить эту проблему - диспетчеризация тегов.

Сначала напишите черты для ваших свойств.

template<class T, class=void>
struct is_pair; // inherits from true_type or false_type depending on if T is a pair.
template<class T, class=void>
struct is_list;

Теперь мы отправляем.

namespace impl {
  template <class pair_t>
  void send(pair_t pair, std::true_type /* is pair */, std::false_type, std::false_type) {
    using first_t = typename pair_t::first_type;
    using second_t = typename pair_t::second_type;

    send<first_t>(std::get<0>(pair));
    send<second_t>(std::get<1>(pair));
  }

  template <typename list_t>
  void send(list_t list, std::false_type, std::true_type /* list */, std::false_type) {
    using value_t = typename list_t::value_type;

    for (const value_t& elem : list) {
      send<value_t>(elem);
    }
  }

  template <typename int_t>
  void send(int_t, std::false_type, std::false_type, std::true_type /* is integral */) {
    std::cout << "Sending integral val: " << val << std::endl;
  }
}
template<class T>
auto send( T t )
-> decltype( impl::send( std::move(t), is_pair<T>{}, is_list<T>{}, std::is_integral<T>{} ) )
{ impl::send( std::move(t), is_pair<T>{}, is_list<T>{}, std::is_integral<T>{} ); }

Answer 3

Ваша проблема в том, что для компилятора ваши объявления для пары и списка выглядят так:

template <typename T>
blah send(T arg) {
    ...
}

... и в этой сигнатуре не используется enable_if.Я думаю, вам нужно поместить enable_if в тип аргумента.(Я бы также взял list_t по константной ссылке - вы не хотите копировать список без необходимости).