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类有两个构造函数;一个用于从String构建int，另一个用于从const指针构建String到char。因此，这两个构造函数也是转换函数，因为它们实际上将一种类型转换为另一种类型。但是，第一个构造函数是显式构造函数。虽然第二个构造函数允许从指向 - 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的函数。这意味着该函数必须隐式地从String 构建int 。这是不可能的，因为相关的构造函数是显式的。如果您从String构建int，然后将String传递给该函数，那么一切都会好的。

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

有一点值得注意的是，如果代码中的整数为0而不是10，代码将编译。原因是0可以隐式地转换为地址（NULL地址）），这是一个带指针的构造函数的有效值。

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

Answer 2

作者正在记录编译器会因为没有转换或选择的转换标记为explicit而导致错误的情况。对于实际可行的案例，代码可能更清晰：

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。使用单个参数构造函数的'explicit'关键字infront，避免这种静默转换。希望这有助于!!! ..

explict test (int x);

隐式转换

4 个答案: