重载的“<brace-enclosed initializer list>”的调用足以满足对的要求是模棱两可的

Question

我无法编译以下代码。

void print_number(long n) {
   std::cout << n << std::endl;
}

void print_number(float n) {
   std::cout << n << std::endl;
}

void print_pair(std::pair<std::string, long> p) {
   std::cout << std::get<1>(p) << std::endl;
}

void print_pair(std::pair<std::string, float> p) {
   std::cout << std::get<1>(p) << std::endl;
}

int main() {
   print_number(12l);
   print_number(3.4f);

   print_pair({"long", 12l});
   print_pair({"float", 3.4f});

   return 0;
}

print_number 函数运行良好。但是，编译器抱怨 print_pair 函数重载： error: call of overloaded ‘print_pair(<brace-enclosed initializer list>)’ is ambiguous.

<brace-enclosed initializer list> 或 std::pair 中的内容是否无法正常工作？如何重载接收std::pair 参数的函数？

Answer 1

Tl;博士

为了解决歧义，可以给编译器提供正确的类型：

print_pair(std::make_pair<std::string, long>("long", 12l));
print_pair(std::make_pair<std::string, float>("float", 3.4f));

或

print_pair(std::make_pair(std::string("long"), 12l));
print_pair(std::make_pair(std::string("float"), 3.4f));

---

歧义问题源于"long"和"float"不是std::string，而是const char[]这一事实。

因此，当您尝试使用以下表达式构造std::pair 时：std::pair{"long", 12l}，您得到的是std::pair<const char[5], long>。

（浮点数相同；即std::pair<const char[5], float>）。

您的过载print_pair 接受std::pair<std::string, long> 或std::pair<std::string, float>。以前的类型都不匹配，因此编译器必须执行转换。因此，它无法自动扣除您要执行的转换。两者都有效。

例如：

                    std::pair<const char[5], long>  
                                  |
  ----------------------------------------------------------------
  v                                                              v
std::pair<std::string, long>                          std::pair<std::string, float>

要“证明”问题是std::string（既不是long 也不是float），您还可以构造一个正确的std::string（而不是char 的数组）来解决歧义：

print_pair(std::make_pair(std::string("long"), 12l));
print_pair(std::make_pair(std::string("float"), 3.4f));

从C++17开始，这个样板可以简化为：

using namespace std::string_literals;

print_pair(std::pair{"long"s, 12l});
print_pair(std::pair{"float"s, 3.4f});

Answer 2

对于print_pair({"long", 12l});，有两种可能的重载：

• void print_pair(std::pair<std::string, long>)
• void print_pair(std::pair<std::string, float>)

{"long", 12l} 没有类型，但对于std::pair<std::string, long> 和std::pair<std::string, long> 都是有效的初始化。

所以调用是模棱两可的。

print_pair(std::pair{"long", 12l}); 也会有歧义
因为std::pair<const char*, long> 可以同样转换为std::pair<std::string, long> 和std::pair<std::string, long>。

你必须调用它：

• print_pair(std::pair{std::string("long"), 12l}); 进行完全匹配。

Answer 3

C++ 的重载解析逻辑不考虑分段转换，它只考虑给定参数/参数对的整体转换。

有了这个电话：

print_pair({"long", 12l});

我们有两个可行的候选人。一名候选人接受std::pair<std::string, long>，另一名候选人接受std::pair<std::string, float>。

C++ 没有做的（以及你可能认为它做的）是分别考虑这些部分 - 并且说，"long" 到 std::string 在两种情况下都是相同的，但 12l 到 @987654327 @ 优于 12l 到 float，因此转换为 pair<string, long> 获胜。这会如果我们有两个接受两个参数的函数，而不是两个接受pairs的函数，它会如何工作：

print_two("long", 12l); // calls print_two(string, long)

但是 C++ 不是这样工作的。它所做的就是将这些部分放在一起考虑。 braced-init-list 可用于构造 std::pair 两个特化。两者都是可行的。两者都是用户定义的转换。两者都不比另一个好，因此模棱两可。我们确实没有语言中的机制来使这种分段转换工作。

你要么直接说出你的意思：

print_pair(std::pair<std::string, long>("long", 12l));

或者取两个参数。

Answer 4

感谢所有回答。我对所有这些都投了赞成票，但是，我想做的是用异构<brace-enclosed initializer list>s 调用函数print_pair。

我最后做的是：

struct number {
    number(long n) {
        std::cout << n << std::endl;
    }
    number(float n) {
        std::cout << n << std::endl;
    }
};

void print_pair(std::pair<std::string, number> p) {}

这样，下面的函数调用就可以不用error: call of overloaded ‘print_pair(<brace-enclosed initializer list>)’ is ambiguous编译了。

print_pair({"long", 12l});
print_pair({"float", 3.4f});

请注意，使用两个structs，其构造函数分别采用long和float，我们将回到同样的歧义问题。