C++ C+中的隐式转换+；

给定以下代码，为什么编译器在构造

Bar

时不解析隐式转换？也就是说，构造

Foo

，就像构造

a

一样，然后它（应该）被用来构造

Bar

#include <string>

class ImplicitlyConvertToChar
{
public:
  ImplicitlyConvertToChar(const char* a_char)
    : m_string(a_char)
  { }

  ImplicitlyConvertToChar(const char* a_char, size_t a_end)
    : m_string(a_char)
  {
  }

  template <typename T_String>
  ImplicitlyConvertToChar(T_String const& a_string)
    : m_string(a_string.begin())
  {
  }

  operator char const * () const
  { return m_string; }

  const char* m_string;
};

class Foo
{
public:

  Foo(const ImplicitlyConvertToChar& a_charLike)
    : m_string(a_charLike)
  { }

  const char* m_string;
};

class Bar
{
public:
  Bar(const Foo& a_foo)
    : m_foo(a_foo)
  { }

  Foo m_foo;
};

int main()
{
  Foo a("this works");
  Bar b("Why doesn't this?");
}

#包括
类隐式ConvertToChar
{
公众：
隐式converttochar（const char*a_char）
：m_字符串（a_字符）
{ }
隐式converttochar（const char*a_char，size_t a_end）
：m_字符串（a_字符）
{
}
模板
隐式ConvertToChar（T_字符串常量和a_字符串）
：m_string（a_string.begin（））
{
}
运算符字符常量*（）常量
{返回m_字符串；}
常量字符*m_字符串；
};
福班
{
公众：
Foo（const隐式converttochar&a_charLike）
：m_字符串（类似字符）
{ }
常量字符*m_字符串；
};
分类栏
{
公众：
酒吧（康斯特福&阿福）
：m_foo（a_foo）
{ }
傅文福,；
};
int main（）
{
富a（“本工程”）；
b栏（“这为什么不呢？”）；
}

不允许有多个用户定义的隐式转换。

Foo

示例涉及一个，而

Bar

示例涉及两个。

编译器只允许进行单个隐式用户定义的转换

看

---

以这种方式构建

Bar

需要两个。这是标准的一部分，隐式转换不能像那样链接。您只能进行一次隐式转换。您的开头句子不正确。允许编译器进行单个隐式用户定义转换。它可以执行任意数量的隐式标准转换。我希望它不喜欢任何转换。@ArmenTsirunyan感谢您指出这一关键疏忽。答案已更新。@ArmenTsirunyan指出，最多只能执行两次标准转换

A user-defined conversion consists of: 
    zero or one non-explicit single-argument constructor or non-explicit 
    conversion function calls