隐式转换

Question

在下面的例子中，作者对隐式转换做了几点注释。您能否更详细地解释一下这些评论，我对这些评论不太清楚。谢谢。

class String{
  explicit String(int n);
  String(const char *p);
}
String  s1= ‘a’;     //error:  no implicit char->String conversion
void f(String);
String g( )
{
   f(10);           // error: no implicit int->String conversion
   return 10;   //  error:  no implicit int-> String conversion
}

Answer 1

String 类有两个构造函数；一种用于从 int 构造 String，另一种用于从指向 char 的 const 指针构造 String。因此，这两个构造函数也是转换函数，因为它们实际上将一种类型转换为另一种类型。然而，第一个构造函数是一个显式构造函数。虽然第二个构造函数允许从指针到 char 到 String 的隐式转换，但第一个构造函数要求您显式请求转换。

例如：

String s;
s = 10;          // error: implicit conversion from int to String
s = String(10);  // ok: explicit conversion of int to String.

第一个错误注释只是说没有用于将 char 转换为 String 的构造函数。同样，我们只有两个构造函数：一个用于转换 int，另一个用于转换 char 的 const 指针。

第二个错误涉及将 int 作为参数传递给需要 String 的函数。这意味着该函数必须隐式从int构造一个String。这是无法完成的，因为相关的构造函数是显式的。如果您从 int 构造一个 String，然后将该 String 传递给函数，一切都会很好。

第三个错误与第二个错误完全相同，只是这里隐式转换（失败）是在返回值应为 String 时返回 int 。

需要注意的一件有趣的事情是，如果代码中的整数为 0 而不是 10，则代码将编译。原因是 0 可以隐式转换为地址（NULL 地址），并且对于采用指针的构造函数来说，这是一个有效值。

String s;
s = 0;   // ok
s = '\0' // ok

Answer 2

作者正在记录一些情况，在这些情况下，编译器会因为没有转换或选择的转换被标记为“显式”而给出错误。如果有一个实际可行的案例，代码可能会更清晰：

class String{
  explicit String(int n);
  String(const char *p);
};
String  s1= ‘a’;     //error:  no implicit char->String conversion
                     // There is a combo implicit/explicit one...
                     // char (implicit) -> int (explicit) -> String

void f(String);

String g( )
{
   f(10);       //  error: no implicit int->String conversion
                //  (the String(int n) constructor is marked explicit).

   f("fred");   //  not an error: uses the String(const char *) constructor
                //  for an implicit conversion.

   f(String(10)); // not an error, explicitly calls the String(int n)
                  // constructor.

   return 10;   //  error:  no implicit int-> String conversion
}

Answer 3

这些注释基本上表明编译器无法知道如何与 String 数据类型进行转换。

请参阅：http://publib.boulder.ibm.com/infocenter/comphelp/v8v101/index.jsp?topic=/com.ibm.xlcpp8a.doc/language/ref/cplr383.htm

另外： http://www.glenmccl.com/tip_023.htm

Answer 4

作为附加信息。首先，为什么我们需要担心隐式转换？考虑以下场景。

#include <iostream>
#include <string>

using namespace std;

class Test
{
  public:
        Test ( int x);
        ~Test ();
        void print ();
        bool operator==(const Test &temp);
  private:
        int _x;
};

Test::Test (int x)
{
  _x = x;
}

Test::~Test ()
{
}

void Test::print ()
{
 cout <<"_x : "<<_x<<endl;
}

bool Test::operator==(const Test & temp)
{
    cout <<"Comparing "<<_x <<" With "<<temp._x<<endl;
    if (_x == temp._x) return 1;
    else
       return 0;
}

int main (int argc, char ** argv)
{
   Test t1(10); //OK
   Test t2 = 10; // We intented
   t1.print ();  /* Excellent */
   t2.print ();

   /* What we do not intend is this : silent Conversion from int to Object */
   /* Hey man i forgot to mention t2, but mentioned '2' instead. */

   if ( t1 == 2 )
    cout <<"TRUE"<<endl;
   else
    cout <<"FALSE"<<endl;
}

它仍然编译，并将整数“2”转换为测试对象，这不是我的意图，而是比较 t1 和 t2。在单参数构造函数前面使用“显式”关键字可以避免这种静默转换。希望这有帮助！

explict test (int x);