User-defined conversions sequence

Question

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{};
}

Afshin · Accepted Answer · 2018-11-14T09:56:27.417

13

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.

edited Nov 14 '18 at 09:56

answered Nov 14 '18 at 09:21

Afshin

8,839
1
18
53

2

Worth noting that OP mentioned `explicit`. In your first example in your edit, there is a temporary `Myclass1` object created *implicitely* from `Myclass` instance (that's why there is a `Myclass2` constructor invoked, which requires `Myclass1` object). If you make `Myclass1`'s constructor `explicit`, it will fail – Fureeish Nov 14 '18 at 09:30
@Fureeish I will add your comment. – Afshin Nov 14 '18 at 09:32
`Myclass2 m2 = Myclass{};` is accepted by VS 2017 if the conformance mode (`/permissive-`) is not activated. – Evg Nov 14 '18 at 09:46
@Evg I didn't know that. I will add it too. – Afshin Nov 14 '18 at 09:52

Evg · Answer 2 · 2018-11-14T10:19:12.003

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.

score 2 · Answer 3 · answered Nov 14 '18 at 11:58

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.

User-defined conversions sequence

3 Answers3