運算符=與轉換運算符結合的歧義

Question

我有以下情況：

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

當我執行此代碼時：

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

我有以下錯誤：

    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)'

假設我無法添加，如何解決這種歧義

A& operator =(const B&)

到A級。

有很多復雜的原因使我必須完全按照這種方式做，但是如果這種方式行得通，那就太好了。

可能有一些優先級或一些類似運算符的顯式關鍵字...任何建議都將受到高度贊賞。

更新：任何類型的強制轉換都不能在代碼的第二部分中使用。 問題是找到僅修改第一個代碼部分的解決方案。

一個更新：代碼第2部分必須按原樣編譯。

Answer 1

這看起來像是多態的工作：

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

演示版

Answer 2

您提出的方式使問題基本上無法解決。

顯然，有兩種從B分配給A的方法，沒有一種是可取的。

唯一的解決方案（不涉及類）是顯式強制轉換，以便您強制進行轉換。

通常，分配和轉換是多余的：如果您接受隱式轉換（使用U::operator T() const -或使用T::T(const U&)從- T::T(const U&) ），則不必提供其他分配而不是默認值，並且如果您要隱式地進行異構分配，則必須不提供轉換，或者最多不要使它們explicit 。