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

Overload ambiguity in C++ for automatically converting objects into a "printable" format

本文关键字：对象 转换 printable 格式 重载 歧义 用于 C++      更新时间：2023-10-16

我正在尝试编写一个接受输入的函数。如果该输入可以直接通过管道传输到流(例如使用 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;
}
此代码在调用可以转换为字符串或可以写入流的对象

时有效，但是如果我有一个既可以转换为字符串又可以写入流的对象，则由于调用哪个函数的歧义，代码会失败。

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

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

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

我的意思是。。。如果为首选版本添加未使用的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。

当只有一个下杠杆版本可用时，可以毫无问题地调用它。

顺便说一下：使用老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;
 }

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

基本思想是为流案例编写一个函数，为其他所有内容编写一个函数。 后一个函数可以假定字符串转换，也可以使用更多的 SFINAE 对其进行测试。 (正确的测试是std::string(std::declval<T>());没有理由将其限制为转换运算符。

但是你不能只是从string过载中删除SFINAE，因为仍然没有一个功能更专业。 并且没有结构限制(即可推导(，您可以在流重载中对模板参数施加以使其更加专业化。

与往常一样，答案是部分专用化：因为在进行模板推导以选择部分专用化之前添加了默认模板参数，因此我们可以将它们用于 SFINAE：

template<class T,class=std::ostream&>
struct printable {
  std::string make(const T& obj) {
    std::cout << "[std::string make_printable(obj)]";
    return (std::string)obj;
  }
};
template<typename T>
struct printable<T,decltype(std::declval<std::ostream&>() << std::declval<T const &>())> {
  const T& make(const T& obj) {
    std::cout << "[const T& make_printable(obj)]";
    return obj;
  }
};
template<class T>
auto make_printable(const T &t)
{return printable<T>::make(t);}

包装器函数通常用于单个名称和模板推导(再次(。

您可以使用帮助程序类将std::declval<StreamT&>() << std::declval<T const &>()的有效性转换为常量 bool 类型，例如

template <typename T, 
          typename StreamT, 
          typename = void>
struct Can_output_directly : std::false_type {};
template <typename T, 
          typename StreamT>
struct Can_output_directly<T, StreamT, std::void_t<decltype(std::declval<StreamT&>() << std::declval<T const &>())>> : std::true_type {};
                                    // ^^^^^^^^^^^ C++17 feature

然后你可以在第一个make_printable中添加一个模板参数：

template <typename T, 
          typename StreamT = std::ostream, // void -> std::ostream
          typename = decltype(std::declval<T>().operator std::string()),
          typename std::enable_if<!Can_output_directly<T, StreamT>::value, int>::type = 0> // note this parameter
std::string make_printable(const T& obj) {
    std::cout << "[std::string make_printable(obj)]";
    return (std::string)obj;
}

现在，仅当Can_output_directly<T, StreamT>::value false时，才会启用此函数模板，即未启用第二个函数模板。

相关文章：