我正在尝试编写一个输入的函数。如果该输入可以直接传送到流（例如使用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是int比long更好的匹配。
当只有一个较低的杠杆版本可用时，它被称为没有问题。
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;
}
我想这是个人品味的问题，但我觉得这样简单一些。
基本思想是为流案例编写一个函数，为其他所有函数编写一个函数。后一个函数可以采用字符串转换，或者可以使用更多的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时才启用此功能模板，即未启用第二个功能模板。