为什么 C++ 隐式转换有效，而显式转换无效？

Question

以下代码在 C++11 中编译成功：

#include "json.hpp"
using json = nlohmann::json ;

using namespace std ;

int main(){
    json js = "asd" ;
    string s1 = js ; // <---- compiles fine
    //string s2 = (string)js ; // <---- does not compile
}

它包括JSON for Modern C++. A working example is in this wandbox。

JSON变量js隐式转换为字符串。但是，如果我取消注释最后一行，这是一个显式转换，它就无法编译。编译结果here.

除了这个 json 库的特殊细微差别之外，您如何编写 class 以便隐式转换有效而显式转换无效？
是否有某种允许这种行为的构造函数限定符？

Answer 1

这是重现相同问题的简化代码：

struct S
{
    template <typename T>
    operator T() // non-explicit operator
    { return T{}; }
};

struct R
{
    R() = default;
    R(const R&) = default;
    R(R&&) = default;
    R(int) {} // problematic!
};

int main()
{
    S s{};
    R r = static_cast<R>(s); // error
}

我们可以看到编译错误类似：

error: call of overloaded 'R(S&)' is ambiguous
     R r = static_cast<R>(s);
                           ^
note: candidates...
     R(int) {}
     R(R&&) = default;
     R(const R&) = default;

问题依赖于泛型 S::operator T()，它会很乐意 return 将值设为您想要的任何类型。例如，将 s 分配给任何类型都有效：

int i = s; // S::operator T() returns int{};
std::string str = s; // S::operator T() returns std::string{};

T推导出转换类型。在 std::string 的情况下，它有很多构造函数，但是如果您执行 object = other 形式的 copy-initialization(1)，则 T 被推导为左侧对象的类型（即 std::string）。

选角是另一回事。看，如果您尝试使用第三种形式（在本例中为 direct initialization）进行复制初始化，也会出现同样的问题：

R r(s); // same ambiguity error

好的，R 的构造函数重载是什么？

R() = default;
R(const R&) = default;
R(R&&) = default;
R(int) {}

鉴于 R 的构造函数可以采用另一个 R 或 int，问题变得很明显，因为模板类型推导系统不知道其中的哪一个由于调用运算符的上下文，这些是正确的答案。在这里，直接初始化必须考虑所有可能的重载。这是基本规则：

A is the type that is required as the result of the conversion. P is the return type of the conversion function template

在这种情况下：

R r = s;

R 是转换结果所需的类型 (A)。但是，你能看出以下代码中 A 将代表哪种类型吗？

R r(s);

现在上下文有 R 和 int 作为选项，因为 R 中有一个接受整数的构造函数。但是转换类型只需要推断为其中之一。 R 是一个有效的候选者，因为至少有一个构造函数采用 R。 int 也是一个有效的候选者，因为也有一个采用整数的构造函数。没有获胜者候选人，因为他们都同样有效，因此模棱两可。

当您将 json 对象转换为 std::string 时，情况完全相同。有一个接受字符串的构造函数，还有一个接受分配器的构造函数。两个重载都是有效的，所以编译器不能 select 一个。

如果将转换运算符标记为 explicit，问题就会消失。这意味着你可以做 std::string str = static_cast<std::string>(json)，但是你失去了像 std::string str = json.

那样隐式转换它的能力

Answer 2

我认为是当你使用显式转换时，编译器必须从代码中使用隐式转换时选择更多的功能。当编译器发现

string s1 = js

它从重载中排除，所有构造函数和转换都标记为 "explicit" 因此它会选择一个函数。相反，当编译器发现时：

string s2 = (string)js ;

它必须包括所有转换，然后是歧义。

为什么 C++ 隐式转换有效，而显式转换无效？

Why C++ implicit conversion works, but explicit one does not?

c++

c++11

casting

implicit-conversion

explicit-conversion