mjhjmtu

Before I studied the explicit keyword, my teacher said: "compiler doesn't execute consecutive user defined conversion". If it is true, are there any errors in my code? Or have I misunderstood my teacher? I'm working in VS2017.

#include<iostream>
#include <string>

class Myclass 
public:
 Myclass() 
 std::cout << "Myclass" << std::endl;
 
;

class Myclass1 
public:
 Myclass1(Myclass m) 
 std::cout << "Myclass1" << std::endl;
 
;
class Myclass2
public:
 Myclass2(Myclass1 m) 
 std::cout << "Myclass2" << std::endl;
 
;

int main() 
 Myclass2 m2 = Myclass;
 

compiler doesn't execute consecutive user defined conversion

Your teacher is right. In your code sample it means Myclass cannot be converted to Myclass1 when you assign in:

Myclass2 m2 = Myclass;

Because constructor expects Myclass1 when creating Myclass2, and compiler cannot consecutively convert Myclass to Myclass1 and then use it for creating Myclass2. But if you have following line:

Myclass1 m2 = Myclass;

It will work, because constructor of Myclass1 takes Myclass as argument.

Update:

You may ask why this works:

Myclass2 m2 Myclass;

Because in this case, constructor is called and conversion can be done implicitly unless you declare Myclass1 as explicit which will fail code compilation (Thanks Fureeish for reminder), but in:

Myclass2 m2 = Myclass;

is like calling copy-constructor which needs reference. so if you write it like this, it will work:

Myclass2 m2 = Myclass1(Myclass);

As EVG mentioned, Myclass2 m2 = Myclass; is accepted by VS 2017 if the conformance mode (/permissive-) is not activated.

The line

 Myclass2 m2 = Myclass;

means copy-initialization. Citing cppreference.com:

If T is a class type, and the cv-unqualified version of the type of other is not T or derived from T [...], user-defined conversion sequences that can convert from the type of other to T [...] are examined and the best one is selected through overload resolution.

Citing further:

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

So, Myclass2 m2 = Myclass; is not acceptable because it would involve two user-defined conversions.

Now let's take a look at

Myclass2 m2 Myclass;

suggested in Afshin's answer. This is a direct-initialization. The rules are different:

The constructors of T are examined and the best match is selected by overload resolution. The constructor is then called to initialize the object.

The constructor of Myclass2 accepts Myclass1, and you need one user-defined conversion to get Myclass1 from Myclass. Hence, it compiles.

Note that in VS copy-initilization is treated like direct-initilization if conformance mode (/premissive-) is not activated (by default). So, VS accepts Myclass2 m2 = Myclass; treating it as direct-initilization. See this document for examples.

The other answers are burying the lede: The code you’ve written is indeed invalid. MSVC accepts it by default, but MSVC is wrong to do so. You can force MSVC to be stricter by using the command line switch /permissive-. (You should use that switch.)

Other compilers (GCC, clang), reject it.

All compilers accept the code once you change the copy initialisation to direct initialisation as shown in the other answers.