为什么是`函数<void (string)> ` 和 ` 函数<string (string)> ` 参数类型有时会因为重载而模棱两可？</string></void>

Question

跟进我的问题c++ - 使用中间类型时隐式转换如何工作？ ，从中我了解了1 隐式转换 max的规则，我试图了解涉及 function arguments 的更高级用例。

假设我有一个 function，它接受另一个 function 作为参数。 该 function 参数可以返回某些内容，也可以不返回任何内容（无效）。 因此，我想重载 function 定义，在一种情况下接受非 void function 参数，在另一种情况下接受 void function 参数。

using VoidType = void (string);
using NonVoidType = string (string);

string call(VoidType *fn, string arg) {
    cout << "[using void function]" << endl;
    fn(arg);
    return arg;
}

string call(NonVoidType *fn, string arg) {
    cout << "[using non void function]" << endl;
    return fn(arg);
}

当调用 function 时，给定的参数具有已知类型，因此重载选择应该很简单，例如这里：

void printVoid(string message) {
    cout << message << endl;
}

string printNonVoid(string message) {
    cout << message << endl;
    return message;
}

void test() {
    call(printVoid, "call(printVoid)");
    call(printNonVoid, "call(printNonVoid)");
}

但这不是当我有中间类型时，例如std::function包装器：

string call(function<VoidType> fn, string arg) {
    cout << "[using void function]" << endl;
    fn(arg);
    return arg;
}

string call(function<NonVoidType> fn, string arg) {
    cout << "[using non void function]" << endl;
    return fn(arg);
}

void test() {
    call(printVoid, "call(printVoid)");
    call(printNonVoid, "call(printNonVoid)"); // more than one instance of overloaded function "call" matches the argument list:C/C++(308)
}

为此，我得到的错误more than one instance of overloaded function "call" matches the argument list:C/C++(308) 。

对此的解决方案是在调用之前显式实例化std::function ：

void test() {
    call(function(printNonVoid), "call(function(printNonVoid))");
}

但是， call(function(printNonVoid), "xxx")与call(printNonVoid, "xxx")有什么不同，知道在后一种情况下，我希望隐式转换与前一种情况下所做的相同.

我是否遗漏了一些东西，比如一些中间的、隐藏的复制构造函数或其他什么？

完整示例：

#include <iostream>

using namespace std;

using VoidType = void (string);
using NonVoidType = string (string);

string callFromPointer(VoidType *fn, string arg) {
    cout << "[callFromPointer] void" << endl;
    fn(arg);
    return "<void>";
}

string callFromPointer(NonVoidType *fn, string arg) {
    cout << "[callFromPointer] non void" << endl;
    return fn(arg);
}

string callFromFunction(function<VoidType> fn, string arg) {
    cout << "[callFromFunction] void" << endl;
    fn(arg);
    return "<void>";
}

string callFromFunction(function<NonVoidType> fn, string arg) {
    cout << "[callFromFunction] non void" << endl;
    return fn(arg);
}

void printVoid(string message) { cout << "\t[printVoid] " << message << endl; }
string printNonVoid(string message) {
    cout << "\t[printNonVoid] " << message << endl;
    return message;
}

void sep() { cout << "\n----\n" << endl; }

void main() {
    callFromPointer(printVoid, "callFromPointer(printVoid)");
    callFromPointer(printNonVoid, "callFromPointer(printNonVoid)");

    sep();

    callFromFunction(printVoid, "callFromFunction(printVoid)");
    callFromFunction(printNonVoid, "callFromFunction(printNonVoid)"); // more than one instance of overloaded function "callFromFunction" matches the argument list:C/C++(308)
    
    sep();

    callFromFunction(function(printVoid), "callFromFunction(function(printVoid))");
    callFromFunction(function(printNonVoid), "callFromFunction(function(printNonVoid))");
}

Answer 1

这是因为std::string(*)(std::string)与std::function<void(std::string)>和std::function<std::string(std::string)> string) “兼容” std::function<std::string(std::string)>因为前者可以简单地忽略底层函数的返回值。

也就是说，以下两个都是有效的：

std::function<void(std::string)> voidFunc(printNonVoid);
std::function<std::string(std::string)> strFunc(printNonVoid);

由于两者都不是“更好”的匹配，因此调用callFromFunction(printNonVoid, "...")时重载解析失败。

---

它在使用std::function(printNonVoid)时起作用的原因是因为 class 模板参数推导接管了，并且有一个T(*)(Args...) -> std::function<T(Args...)> . 该演绎指南将std::function(printNonVoid)变成std::function<std::string(std::string)>(printNonVoid) 。 因为这是一个完全匹配，不需要转换std::function<std::string(std::string)> callFromFunction的重载，重载是由重载决议选择的。

That deduction guide doesn't come into play when performing overload resolution with just the raw function name though, since the function arguments have to explicitly declare std::function 's template argument.