c++ - 在不明确时在转换运算符之间进行选择

Question

我有两种类型:

struct A { };
struct B { };

而且我有采用A 或B 的函数:

void fnA(A); // there are a lot of these functions
void fnB(B);

我有一个类型，它可以转换为 A 和 B:

struct Foo {
    operator A();
    operator B();
};

所以我可以调用 fnA 和 fnB:

fnA(Foo()); // fine
fnB(Foo());

现在，我重载了函数:

void fn(A);
void fn(B);

我不能用 Foo 调用它们，因为它不明确:

fn(Foo()); // ambiguous, which fn is called

在这种情况下，我想调用 fn(A)。

我可以添加第三个 fn 重载:

inline void fn(Foo foo) {
    fn(A(foo));
}

但我不喜欢这种方式，因为我有很多 fn 函数，而且我不想大幅增加函数的数量(我有 fn-like 函数散落在各处，这种变化会增加界面大小，这对我不利，因为我的界面已经很大了)。

另一种解决方案(如果没有给出更好的选择，我会选择它)是对 Foo 使用继承:

struct Foo: A {
    operator B();
};

在这种情况下，编译器会选择为fn(Foo())调用fn(A)，这就不再有歧义了。但我对这个解决方案并不满意，因为 Foo 并不是真正的 A，它是对继承的滥用(另一方面，它是一个更好的解决方案，因为前一个，因为它在本地解决了问题，所以我不必添加很多不需要的 fn 函数)。

还有其他方法可以解决这个问题吗？

注意:我想要一个不涉及显式转换的解决方案，我希望能够编写 fnA(Foo()), fnB(Foo( )) 和 fn(Foo())。

Answer 1

花哨的模板包装器怎么样:

void fn_impl(A);
void fn_impl(B);

template<typename x_AB = A, typename x_Foo = Foo>
void fn(x_Foo && foo)
{
    return fn_impl(static_cast<x_AB>(foo));
}

fn(Foo()); // calls fn_impl(A);
fn<B>(Foo()); // calls fn_impl(B);

online compiler