如何解决C ++ 20概念要求存在确切的函数签名
请考虑以下示例来计算两个值之间的绝对差。
q)ungroup update result:first[Call_Function] each ([]aa;bb;cc) by Call_Function from t
id seg aa bb cc Uknown Call_Function result
---------------------------------------------------
AAA 1 1500 0.4 bb Solvebb 1236.3
AAA 1 1500 0.4 bb Solvebb 2065.016
AAA 1 1500 0.4 bb Solvebb 2620.522
AAA 1 1500 0.4 bb Solvebb 2992.888
AAA 1 1500 0.4 bb Solvebb 3242.493
AAA 2 200 0.25 aa Solveaa 200.25
AAA 2 200 0.25 aa Solveaa 50
AAA 3 400 30 cc Solvecc 430
AAA 3 400 30 cc Solvecc 12000
BBB 1 40 40 cc Solvecc 80
BBB 1 40 40 cc Solvecc 1600
CCC 1 900 0.35 bb Solvebb 759.3735
CCC 1 900 0.35 bb Solvebb 1294.495
CCC 1 900 0.35 bb Solvebb 1671.589
CCC 1 900 0.35 bb Solvebb 1937.322
CCC 1 900 0.35 bb Solvebb 2124.581
对于某些内置类型，template<class T>
auto abs_diff(const T _a,const T _b) {
return (_a > _b) ? (_a - _b) : (_b - _a);
}
提供了卓越的性能，因此，如果存在std::abs，我想使用它（假设我们对整数的情况下不同的下溢/上溢行为不感兴趣）。为此，我尝试添加以下受约束的模板函数
std::abs(T x)现在，template<class T> requires requires (T x) { std::abs(x); }
auto abs_diff(const T _a,const T _b) {
return std::abs(_a - _b);
}
存在的所有类型都将使用此专用版本。但是，所有隐式可转换类型都可以使用这种类型，这是不希望的。所以我的问题是：有没有一种方法要求在概念中存在具有精确签名的函数（即std::abs的存在，而不仅仅是std::abs(T x)编译的事实）。
注意：上面的示例主要用于说明，并且至少对于我的应用程序可以通过使用std::abs(x)约束返回类型来修复。但是，我对这种问题的一般解决方案感兴趣。
解决方法
我们可以代替地测试重载的函数地址表达式&std::abs是否可以转换为具有所需签名的函数的指针。或者我们可以，除了C ++ 20不允许形成指向大多数标准库函数的指针。
在此处保留原始答案以获取信息。对于标准库中没有的重载函数名称，这将是有效的模式。而且无论如何它通常都能正常工作，但是我们不应该依靠它来继续使用较新的库版本。
#include <cmath>
template<class T>
auto abs_diff(const T _a,const T _b) {
return (_a > _b) ? (_a - _b) : (_b - _a);
}
template<class T> requires requires (T (*fp)(T)) { fp = &std::abs; }
auto abs_diff(const T _a,const T _b) {
return std::abs(_a - _b);
}
在包含匹配函数模板的名称上使用此技术时，如果没有非模板函数完全匹配，则也可以满足约束条件，但是一个最专业的函数模板可以推导其参数，以便专长就是T(T)。
（std::abs中声明了一个<complex>函数模板，但是它永远无法与T(T)类型完全匹配。）
由于讨论了@aschepler的答案，我想出了以下解决方案，该解决方案也应适用于标准库函数，因为std::abs是其中一种：
template<class T>
struct BlockImplicitConversion {
BlockImplicitConversion(const T& _arg);
operator T();
};
template<class T>
auto abs_diff(const T _a,const T _b) {
return (_a > _b) ? (_a - _b) : (_b - _a);
}
template<class T> requires requires (T x) { std::abs(BlockImplicitConversion(x)); }
auto abs_diff(const T _a,const T _b) {
return std::abs(_a - _b);
}
合理的原因是，最多执行一次隐式用户定义的转换。因此，使用代理类BlockImplicitConversion可以防止进一步的隐式强制转换。同时仍然允许标准转换序列，例如对于short，将调用专用模板，并执行对int的强制转换。
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。