CODEWITHSUNDEEP
c++castingtype-conversionimplicit-conversion
MvG
MvG

Reputation: 60868

Interconvertible types and ambiguous calls

I have a sequence of types, which I want to be freely convertible to one another. Consider the following toy example:

struct A {
  int value;
  A(int v) : value(v) { }
};

struct B {
  int value;
  B(int v) : value(v) { }
  B(A a) : value(a.value) { }
  operator A() const { return A(value); }
};

struct C {
  int value;
  C(int v) : value(v) { }
  C(A a) : value(a.value) { }
  C(B b) : value(b.value) { }
  operator B() const { return B(value); }
  operator A() const { return A(B(*this)); } // <-- ambiguous
};

int main(int argc, const char** argv) {
  C c(5);
  A a(3);
  a = c;
}

So as you see, I'm trying to defined each subsequent type to be convertible from all previous types using cast constructors, and to be convertible to all previous types using cast operators. Alas, this does not work as intended, as the definition of C::operator A is ambiguous according to gcc 4.7:

 In member function ‘C::operator A() const’:
19:40: error: call of overloaded ‘B(const C&)’ is ambiguous
19:40: note: candidates are:
9:3: note: B::B(A)
6:8: note: constexpr B::B(const B&)
6:8: note: constexpr B::B(B&&)

Changing the expression to static_cast<A>(static_cast<B>(*this)) doesn't change a thing. Removing that line altogether results in an error message in main, as no implicit conversion sequence may use more than one user-defined conversion. In my toy example, I could perform the conversion from C to A direcly, but in my real life application, doing so would cause a lot of duplicate code, so I'd really like a solution which reuses the other conversion operators.

So how can I obtain a set of three freely interconvertible types without duplicating conversion code?

Upvotes: 0

Views: 101

Answers (2)

John Zwinck
John Zwinck

Reputation: 249153

I'd try this way in struct C:

operator A() const { return this->operator B(); }

Upvotes: 1

Pubby
Pubby

Reputation: 53047

Try this:

operator A() const { return A(B(value)); }

or this:

operator A() const { return A(operator B()); }

Upvotes: 1

Related Questions