c++ - C++ 中用于自动将对象转换为 "printable"格式的重载歧义

Question

我正在尝试编写一个接受输入的函数。如果该输入可以直接通过管道传输到流(例如使用 std::cout << )，它会原封不动地返回输入。否则，它会尝试将输入转换为字符串，并返回该字符串。

我有以下代码:

//Uses SFINAE to determine which overload to call
//See: https://en.wikipedia.org/wiki/Substitution_failure_is_not_an_error
//Basically, make_printable detects whether an object can be directly piped to a stream.
//If it can't be piped to a stream, it's converted into a string.
template<typename T, 
        typename StreamT = void, 
        typename = decltype(std::declval<T>().operator std::string())>
std::string make_printable(const T& obj) {
    std::cout << "[std::string make_printable(obj)]";
    return (std::string)obj;
}

template<
        typename T, 
        typename StreamT = std::ostream,
        typename = decltype(std::declval<StreamT&>() << std::declval<T const &>())>
const T& make_printable(const T& obj) {
    std::cout << "[const T& make_printable(obj)]";
    return obj;
}

当调用可以或者转换成字符串的对象时，这段代码可以工作，或者可以写入流，但是如果我有一个对象可以< em>两者 都被转换为字符串并写入流，代码因调用哪个函数的歧义而失败。

我如何重写这些函数，或者解决这种歧义，以便既可以转换为字符串又可以写入流的对象按原样输出？

Answer 1

How can I rewrite these functions, or resolve this ambiguity, so that objects which can be both converted into a string and written to a stream are output as-is?

如果您可以添加一个间接级别，一种可能的方法是使用首选重载。

我的意思是...如果您为首选版本添加一个未使用的 int 参数，为另一个版本添加一个 long 参数

template<typename T, 
        typename StreamT = void, 
        typename = decltype(std::declval<T>().operator std::string())>
std::string make_printable (T const & obj, long)
 {                                     //  ^^^^ <-- long argument
   std::cout << "[std::string make_printable(obj)]";
   return (std::string)obj;
 }

template<
        typename T, 
        typename StreamT = std::ostream,
        typename = decltype(std::declval<StreamT&>() << std::declval<T const &>())>
T const & make_printable (T const & obj, int)
 {                                    // ^^^ <-- int argument
   std::cout << "[const T& make_printable(obj)]";
   return obj;
 }

并且如果您添加一个上层 make_printable() 来接收值并使用 int 传递它

template <typename T>
auto make_printable (T const & obj)
 { return make_printable(obj, 0); }

当两个较低级别的版本都可用时，第二个是首选，因为 int 比 long 更适合 int。

当只有一个低杠杆版本可用时，调用没有问题。

En passant:使用旧的auto ... -> decltype() 方式来表达返回类型，SFINAE 可以通过以下方式应用于您的函数

template <typename T>
auto make_printable (T const & obj, long)
   -> decltype( obj.operator std::string() )
 {
   std::cout << "[std::string make_printable(obj)]";
   return (std::string)obj;
 }
template <typename T, typename StreamT = std::ostream>
auto make_printable (T const & obj, int)
   -> decltype( std::declval<StreamT>() << obj , obj )
 {
   std::cout << "[const T& make_printable(obj)]";
   return obj;
 }

我想这是个人品味的问题，但我觉得这种方式更简单一些。