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;
}

这很好用，但我的字符串有问题。因为字符串是可迭代的，字符串HAVE 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 vs 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

你可以编写一个小的检测习语来测试表达式stream << value是否格式良好*。

这是使用std::ostream：

template<class...>
using void_t = void;

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;

现在您可以像operator<<那样为template<template<class...> class C, class...T> std::enable_if_t<!can_print_v<C<T...>>, std::ostream>& operator<<(std::ostream &out, C<T...> const &t) { for (auto const &e : t) out << e << " "; out << std::endl; return out; }编写重载：

std::vector<float> a = { 54, 25, 32.5 };
std::vector<int> b = { 55, 65, 6 };
std::cout << a;
std::cout << b;
std::cout << std::string("lol") << std::endl;

和测试

!can_print_v

Demo

Yakk在their answer中指出了一件有趣的事情。 This sentence is false。

基本上，通过使用operator<<为can_print_v启用重载，true应该随后为false，但它是std::false_type因为第一次实例化模板导致结构派生自can_print_v。因此sudo gem install -n /usr/local/bin cocoapods的后续测试无效。

我将这个答案留作警示故事。特质本身是可以的，但是将它用于SFINAE会使特性无效的东西也不行。

^{*看来OP已将此代码复制到他们自己的代码库中，然后将问题修改为包含它，以防您想知道为什么它看起来相反}

Answer 2

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

与此同时，我会说你的计划很糟糕。由于两个原因，重载std类型的运算符是一个糟糕的计划。

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

其次，如果您这样做，则应该在该类型的命名空间中执行此操作，并且如果不使您的程序格式错误，则无法将<<注入namespace std。

在不同于相关类型的命名空间中重载的运算符只能在执行重载的命名空间中找到。可以在任何地方找到与参数相关的命名空间中重载的运算符。

这导致脆弱的<<仅在一个命名空间中起作用。

所以，相反，这样做：

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)};
}

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

Live example使用此测试代码：

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

输出为1,2,3,4。

如何进行递归：

我们可以编写一个adapt_for_streaming函数，发送给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的可流式集合，而不是字符串。

SFINAE：知道功能是否已存在或不存在

2 个答案:

Demo