模棱两可：优先重载 f(A&) 而不是 f(A)

Question

如何优先（告诉编译器）使用 "a function receive reference" (#B) 而不是 "a function receive value" (#A)？

#include <iostream>
using namespace std;

class Heavy{/* ...... */}; //a complex class
Heavy generateHeavy(){
    return Heavy();
}
void f(Heavy x){   //#A I want LOW priority.
    std::cout<<"case 1: pass by value"<<std::endl;
}
void f(Heavy& x){  //#B I want HIGH priority.  (save CPU for big object)
    std::cout<<"case 2: pass by reference"<<std::endl;
}

int main() {
    //vvvv Here is existing code base that I don't want to touch.
    f(generateHeavy());   //compiler call case 1 -> ok (I prefer reference, though)
    Heavy heavy;
    f(heavy); //should call case 2, but compiler fail (ambiguous) <= question
    return 0;
}

这个问题来自我第一次尝试将 SFINAE 扩展到一个更喜欢通过引用传递的真实案例，如果可能的话。

Answer 1

按照您的要求真正做到的方法是

template <typename T = void>
std::enable_if_t<std::is_same<T, void>::value> f(Heavy x) { ... }

void f(Heavy& x) { ... }

第一个是函数模板，但只允许T = void。第二个不是。在其他条件相同的情况下，非模板优先于模板。

现在，在实际代码中，您可能不会这样做。您将查看您希望支持哪些调用，并找到适合这些调用的更合适的方法。 @StoryTeller 建议 &&:

void f(Heavy &&) { ... }
void f(Heavy &) { ... }

这意味着当你有一个右值时，比如你的函数结果， Heavy && 重载将被调用。这通常没问题，但请注意，它与您要求的并不完全相同：

const Heavy c;
f(c);

您所要求的将进行此调用 f(Heavy)。相反，使用 Heavy && 重载，没有接受这个的重载。

额外的重载 void f(const Heavy &) 可以解决这个问题。问题中没有足够的信息来判断这是否适合您的用例，但这是您应该能够自己弄清楚的事情。

模棱两可：优先重载 f(A&) 而不是 f(A)

Ambiguous : Prioritize overloading of f(A&) over f(A)

c++

sfinae

ambiguous