如果未实施除法运算符,则SFINAE回退

我想编写一个函数,它在两个参数a和b不同类型之间执行除法,a/b如果定义了除法运算符,则使用表达式,或者a * (1/b)如果没有这样的运算符则返回.

这是我的想法,但我不知道如何定义两个*和/运算符时禁用第二个定义(或优先第一个定义):

template
auto smart_division(T a, U b) -> decltype (a/b) {
    return a/b;
}
template
auto smart_division(T a, U b) -> decltype (a * (U(1)/b)) {
    return a * (U(1)/b);
}

Piotr Skotni.. 20

最简单的技巧是依赖已经定义其优先级规则的重载决策.在下面的溶液中,用一个额外的参数0,0 -> int是优于0 -> char,因此,前者将是优选的一个如果不是由表达式SFINAE排除在外,而后者仍然可行的后备调用.

#include 

template 
auto smart_division_impl(T a, U b, int)
    -> decltype(a/b)
{
    return a/b;
}

template 
auto smart_division_impl(T a, U b, char)
    -> decltype(a * (U(1)/b))
{
    return a * (U(1)/b);
}

template 
auto smart_division(T&& a, U&& b)
    -> decltype(smart_division_impl(std::forward(a), std::forward(b), 0))
{
    return smart_division_impl(std::forward(a), std::forward(b), 0);
}

template  struct rank : rank {};
template <> struct rank<0> {};

template 
auto smart_division_impl(T a, U b, rank<2>) -> decltype(a/b) 
//                                 ~~~~~~^ highest priority
{
    return a/b;
}

template 
auto smart_division_impl(T a, U b, rank<1>) -> decltype(a * (U(1)/b))
//                                 ~~~~~~^ mid priority
{
    return a * (U(1)/b);
}

template 
int smart_division_impl(T a, U b, rank<0>)
//                                ~~~~~~^ lowest priority
{
    return 0;
}

template 
auto smart_division(T&& a, U&& b)
    -> decltype(smart_division_impl(std::forward(a), std::forward(b), rank<2>{}))
{
    return smart_division_impl(std::forward(a), std::forward(b), rank<2>{});
}

#include 

template 
auto smart_division_impl(T a, U b, int)
    -> decltype(a/b)
{
    return a/b;
}

template 
auto smart_division_impl(T a, U b, char)
    -> decltype(a * (U(1)/b))
{
    return a * (U(1)/b);
}

template 
auto smart_division(T&& a, U&& b)
    -> decltype(smart_division_impl(std::forward(a), std::forward(b), 0))
{
    return smart_division_impl(std::forward(a), std::forward(b), 0);
}

template  struct rank : rank {};
template <> struct rank<0> {};

template 
auto smart_division_impl(T a, U b, rank<2>) -> decltype(a/b) 
//                                 ~~~~~~^ highest priority
{
    return a/b;
}

template 
auto smart_division_impl(T a, U b, rank<1>) -> decltype(a * (U(1)/b))
//                                 ~~~~~~^ mid priority
{
    return a * (U(1)/b);
}

template 
int smart_division_impl(T a, U b, rank<0>)
//                                ~~~~~~^ lowest priority
{
    return 0;
}

template 
auto smart_division(T&& a, U&& b)
    -> decltype(smart_division_impl(std::forward(a), std::forward(b), rank<2>{}))
{
    return smart_division_impl(std::forward(a), std::forward(b), rank<2>{});
}

#include 

template
auto helper(T a, U b, int) -> decltype (a/b) {
    std::cout << "first";
    return a/b;
}

template
auto helper(T a, U b, ...) -> decltype (a * (U(1)/b)) {
    std::cout << "second";
    return a * (U(1)/b);
}

template
auto smart_division(T a, U b) -> decltype (helper(a, b)) {
    return helper(a, b, 0);
}


struct Test {
    explicit Test(int) {}
};
int operator / (Test a, Test b) {
return 1;
}

int main() {
    std::cout << smart_division(1.0, 2.0);
    Test t{5};
    std::cout << smart_division(1, t);
    return 0;
}