Prefer one type convert into another through implicit constructor or implicit conversion operator?

Question

Assume we have procedure void f(X2);. Further assume we have types X1 and X2 that do not share an inheritance hierarchy.

We want to call it like this: f(X1{}) and have X1 implicitly convert into X2. We have two options of achieving this:

struct X2 {};
struct X1 { operator X2(); };

struct X1 {};
struct X2 { X2(const X1&); };

Implementation-wise there are practical differences between the two with the order things are defined and how private data is accessed.

But from a user perspective, are there any cases where these two approaches will behave differently? If so, which of the two is preferable?

This question remains the same even if we mark both explicit. One difference that arises then is that conversion through the constructor is only available in the former case but static_cast works with either.

Answer 1

Both approaches are functionally equivalent, so as to let you define both kinds of conversion even if one of the types is a class you cannot modify, or is not a class at all, like a fundamental type.

In the implicit case, both options will let you call f(X1{}), in the explicit case they will both allow f(X2{X1{}}). The second option simply uses the converting constructor directly, while the first option uses X2's copy or move constructor, which takes its argument from the conversion operator. The actual copy or move operation will be elided, so there is no difference in performance.