为什么'explicit'关键字允许隐式转换？

Question

class Test {

    private:
    int value;

    public:
    void display(void)
    {
        cout << "Value [" << value << "]" << endl;
    }
    explicit Test(int i)
    {
        value=i;
    }   
};

int main() {

    Test a(5);
    Test b(4.9);

    a.display();
    b.display();

    cin.get();
    return 0;
}

Float value gets converted to int even though explicit is mentioned.

I was expecting (incorrectly) that float does not get converted to integer and object b not to be constructed.

Answer 1

explicit does not prevent implicit conversions of constructor parameters . It means that the constructor itself may not be used as an implicit conversion to your class type Test .

void func( Test );  // function declaration

func( 5 ); // Your "explicit" makes this call an error.

To prevent implicit conversions of parameters for your constructor (or any function) you may use the C++11 = delete syntax.

  Test(int i)
  {
      value=i;
  }   

  template<typename T>
  Test(const T&) = delete;
  // ^ Aside from your int constructor and the implicitly-generated 
  // copy constructor, this will be a better match for any other type

Answer 2

explicit just prevents any implicit conversions. So if you had:

void foo(Test t);

You cannot call foo(4); because the Test constructor is explicit . You'd have to call foo(Test(4)); . The explicit keyword has nothing to do with any conversions that might have to happen during construction.

From the standard [class.conv.ctor]:

An explicit constructor constructs objects just like non-explicit constructors, but does so only where the direct-initialization syntax (8.5) or where casts (5.2.9, 5.4) are explicitly used.

Which means that Test t = 4; is also illegal, but Test t(42.0) is fine.

Answer 3

It's a Floating–integral conversion .
That is: it's an implicit conversion between a prvalue of type double to a prvalue of type signed int . It discards the fractional part.

TL;DR: the conversion happens between 'double' and 'int', not in your Test constructor. If you want to prevent that constructor to be called with a float or a double you can add the definition:

Test(double) = delete;

In your Test class. Live on compiler explorer