c++ - SFINAE : Know if a function already exist or no

Question

基本上，我想编写这样的代码:

std::vector<float> a = { 54, 25, 32.5 };
std::vector<int> b = { 55, 65, 6 };

std::cout << a << b << std::string("lol");

这是不可能的，因为 operator<<(ostream&, vector) 没有过载

所以，我编写了一个函数来完成这项工作:

template<template<typename...> typename T, typename ...Args>
std::enable_if_t<is_iterable_v<T<Args...>>>, std::ostream> &operator<<(std::ostream &out, T<Args...> const &t) {
    for (auto const &e : t)
        out << e << " ";
    out << std::endl;
    return out;
}

效果很好，但我对字符串有疑问。因为字符串是可迭代的并且字符串有 operator<<功能。

所以我测试了另一个特征，比如 !is_streamable_out && _is_iterable测试类似的东西:std::declval<std::ostream&>() << std::declval<T>()以及它是否具有开始/结束功能。它在 MSVC 上运行良好，但在 Clang 上运行良好(我认为这是因为编译器也使用了我刚刚创建的函数，所以它发现一个重载可用于所有方法)。

所以，我目前正在使用 !is_same_v<string, T>但这并不完美恕我直言。

有没有办法在不重新声明函数的情况下知道函数是否存在？

基本上，我想做那样的事情

if function foo does not exist for this type.
then function foo for this type is ...

这不是同一个问题 Is it possible to write a template to check for a function's existence?因为在另一个线程中，函数并不完全相同(toString 与 toOptionalString)。就我而言，功能是相同的。

这是我的完整代码:

template <class...>
struct make_void { using type = void; };

template <typename... T>
using void_t = typename make_void<T...>::type; // force SFINAE

namespace detail {
    template<typename AlwaysVoid, template<typename...> typename Operator, typename ...Args>
    struct _is_valid : std::false_type {};


    template<template<typename...> typename Operator, typename ...Args>
    struct _is_valid<void_t<Operator<Args...>>, Operator, Args...> : std::true_type { using type = Operator<Args...>; };
}

template<template<typename ...> typename Operator, typename ...Args>
using is_valid = detail::_is_valid<void, Operator, Args...>;

#define HAS_MEMBER(name, ...)\
template<typename T>\
using _has_##name = decltype(std::declval<T>().name(__VA_ARGS__));\
\
template<typename T>\
using has_##name = is_valid<_has_push_back, T>;\
\
template<typename T>\
constexpr bool has_##name##_v = has_##name<T>::value

HAS_MEMBER(push_back, std::declval<typename T::value_type>());
HAS_MEMBER(begin);
HAS_MEMBER(end);

template<typename T>
using is_iterable = std::conditional_t<has_begin_v<T> && has_end_v<T>, std::true_type, std::false_type>;

template<typename T>
constexpr bool is_iterable_v = is_iterable<T>::value;



template<class T, class Stream, class = void>
struct can_print : std::false_type {};

template<class T, class Stream>
struct can_print<T, Stream, void_t<decltype(std::declval<Stream&>() << std::declval<const T&>())>> : std::true_type {};

template<class T, class Stream = std::ostream>
constexpr bool can_print_v = can_print<T, Stream>::value;

template<typename T>
std::enable_if_t<is_iterable_v<T> && !can_print_v<T>, std::ostream> &operator<<(std::ostream &out, T const &t) {
    for (auto const &e : t)
        out << e << " ";
    out << std::endl;
    return out;
}

template<typename A, typename B>
std::ostream &operator<<(std::ostream &out, std::pair<A, B> const &p) {
    out << p.first << " " << p.second << std::endl;
    return out;
}

template<typename T>
std::enable_if_t<has_push_back_v<T>, T> &operator<<(T &c, typename T::value_type const &e) {
    c.push_back(e);
    return c;
}

和主要的:

#include <iostream>
#include <vector>
#include "Tools/stream.h"
#include <string>
#include <map>

int main() {
    std::vector<float> a = { 54, 25, 32.5 };
    std::vector<int> b = { 55, 65, 6 };

    std::cout << a;

    std::cout << has_push_back<float>::value  << " " << has_push_back<std::vector<float>>::value << std::endl;
    std::cout << is_iterable<std::vector<float>>::value << " " << is_iterable<float>::value << std::endl;

    getchar();
    return 0;
}

Answer 1

How to avoid this sentence is false in a template SFINAE?提供解决您问题的答案——重载 <<(ostream&, Ts...) ，将发现其优先级低于任何其他 <<过载。

同时我要说你的计划很糟糕。 std 的重载运算符types 是一个糟糕的计划，原因有两个。

首先，除非有充分的理由，否则您应该不愿意为不属于您的类型重载运算符。

其次，如果你这样做，你应该在类型的命名空间中进行，你不能注入(inject)你的<<。进入namespace std而不会使您的程序格式错误。

在不同于所讨论类型的 namespace 中重载的运算符只能在您进行重载的 namespace 中找到。在与参数相关的 namespace 中重载的运算符随处可见。

这导致脆弱 <<仅适用于一个命名空间。

---

因此，改为这样做:

struct print_nothing_t {};
inline std::ostream& operator<<(std::ostream& os, print_nothing_t) {
  return os;
}
template<class C, class Sep=print_nothing_t>
struct stream_range_t {
  C&& c;
  Sep s;
  template<class T=print_nothing_t>
  stream_range_t( C&& cin, T&& sin = {} ):
    c(std::forward<C>(cin)),
    s(std::forward<T>(sin))
  {}
  friend std::ostream& operator<<(std::ostream& os, stream_range_t&& self) {
    bool first = true;
    for (auto&& x:self.c) {
      if (!first) os << self.s;
      os << decltype(x)(x);
      first = false;
    }
    return os;
  }
};
template<class C, class Sep = print_nothing_t>
stream_range_t<C, Sep> stream_range( C&& c, Sep&& s={} ) {
  return {std::forward<C>(c), std::forward<Sep>(s)};
}

现在，如果您希望嵌套 vector 起作用，您必须实现一个流范围，将适配器应用于其内容。

Live example使用此测试代码:

std::vector<int> v{1,2,3,4};
std::cout << stream_range(v, ',') << "\n";

输出是1,2,3,4 .

---

如何使这个递归:

我们可以写一个adapt_for_streaming分派(dispatch)给 identity 的函数(对于已经流式传输的东西)，并发送到 stream_range对于可迭代但尚未流式传输的事物。

然后用户可以添加新的 adapt_for_streaming其他类型的重载。

stream_range_t然后使用 adapt_for_streaming 进行流式传输关于其内容。

接下来，我们可以将元组/对/数组重载添加到 adapt_for_streaming突然std::vector< std::vector< std::tuple<std::string, int> > >可以流式传输。

终端用户可以调用stream_range直接，或adapt_for_streaming , 串一个可迭代的容器。您甚至可以调用 stream_range直接在 std::string 上将其视为 char 的可流式集合而不是字符串。