运算符=与转换运算符结合的歧义

Question

I have the following situation:

    class B;

    class A {
    private:
        int n;
    public:
        A& operator=(const A& a) {
        }

        A& operator=(const int n) {
            this->n = n;
        }

        friend class B;
    };

    class B {
    private:
        A a;
    public:
        operator A&() {
            return a;
        }

        operator int&() {
            return a.n;
        }
    };

When I execute this code:

    A a;
    B b;
    int i = b;
    a = b;
    a = i;

I have the following error:

    error C2593: 'operator =' is ambiguous
    ..\CrossPPTest\TestProxy.cpp(40): could be 'A &A::operator =(const int)'
    ..\CrossPPTest\TestProxy.cpp(37): or       'A &A::operator =(const A &)'
    while trying to match the argument list '(A, B)'

How to resolve this ambiguity assuming I can not add

A& operator =(const B&)

to class A.

There are complex reasons why I have to do exactly like this, but it would be really nice if thing like this will work.

May be there are some priorities or something like explicit keyword for operators... Any suggestions are highly appreciated.

UPDATE: Any kind of casts can not be used in second part of code. The thing is to find a solution modifying the first code part only.

ONE MORE UPDATE: Code part #2 MUST compile as is.

Answer 1

This looks like a job for polymorphism:

class B;

class A {
   int n;
   public:
      A& operator=(const A& a) {...}

    A& operator=(const int n) {
      this->n = n;
      return *this;
    }

    friend class B;
};

class B : public A {
   A a;
   public:
     operator int&() {
         return a.n;
     }
};

int main() {
    A a;
    B b;
    int i = b; // works
    a = b; // works
    a = i;
}

Demo

Answer 2

The way you posed makes the problem substantially unsolvable.

There are clearly two ways to assign to an A from a B , none of which is preferable.

The only solution (without touching the classes) is to explicitly cast, so that you force which conversion has to take place.

In general, assignment and conversion are redundant: if you admit implicit conversion (either to - with U::operator T() const - or from - with T::T(const U&) ) you don't have to provide assignment other than the default, and if you want implicit heterogeneous assignments, you must not provide conversion, or at most make them explicit .