交叉赋值运算符？

Question

现在是我第一个问题的时候了。 如何在两个类之间交叉赋值运算符？

class B;

class A {
public:
A &operator = ( const B &b );
friend B &B::operator = ( const A &a ); //compiler error
};

class B {
public:
B &operator = ( const A &a );
friend A &A::operator = ( const B &b );
};

我搜索了如何转发声明成员 function ，例如：

class B;
B &B::operator = ( const A &a ); //error

但我什么也没找到。 而且我不想让班级彼此成为完全的朋友。 我该怎么做呢？

Answer 1

没有办法前向声明成员函数。 我不确定是否有比这更优雅的方式来获得你想要的东西（我从来没有理由做这样的事情），但是对于第二个 class 来说，非会员 function 会起作用那是两个班级的朋友，并将复制委托给它。 请注意， operator= 本身不能是非成员，但这样的事情应该可以工作：

class B;

class A {
public:
  A& operator = ( const B &b );
  friend B& do_operator_equals ( B& b, const A& b);
};

class B {
public:
  B &operator = ( const A &a );
  friend A& A::operator = ( const B &b );
  friend B& do_operator_equals ( B& b, const A& a);
};

然后在你的实现文件中

A& A::operator= (const B& b) {
   // the actual code to copy a B into an A
   return *this;
}

B& B::operator= (const A& a) {
   return do_operator_equals(*this, a);
}

B& do_operator_equals(B& b, const A& a) {
  // the actual code to copy an A into a B
  return b;
}

编辑：把 A 和 B 弄反了，哎呀。 固定的。

Answer 2

编译器错误的原因是循环依赖。 您的每个 operator=() 函数都需要了解其他 class 中的 operator=() function，因此无论您以哪种顺序定义类，总会出现错误。

这是一种解决方法。 它不是很优雅，但它会做你想做的事：

class A;
class B;

A & set_equal(A & a, const B & b);
B & set_equal(B & a, const A & a);

class A
{
    private:
        int x;
    public:
        A & operator=(const B & b) { return set_equal(*this, b); }
        friend B & set_equal(B & b, const A & a);
        friend A & set_equal(A & a, const B & b);
};

class B
{
    private:
        int y;
    public:
        B & operator=(const A & a) { return set_equal(*this, a); }
        friend A & set_equal(A & a, const B & b);
        friend B & set_equal(B & b, const A & a);
};

A & set_equal(A & a, const B & b) { a.x = b.y; return a; }
B & set_equal(B & b, const A & a) { b.y = a.x; return b; }

您也可以使用 inheritance 解决此问题。

编辑：这是使用 inheritance 的示例。 如果复制过程只需要访问 A 和 B 共享的一些公共数据，这将起作用，如果 = 运算符根本没有任何意义，这似乎很可能。

class A;
class B;

class common
{
    protected:
        int x;
        void copyFrom(const common & c) { x = c.x; }
};

class A : public common
{
    public:
        A & operator=(const common & c) { copyFrom(c); return *this; }
};

class B : public common
{
    public:
        B & operator=(const common & c) { copyFrom(c); return *this; }
};

Answer 3

你为什么希望他们首先成为朋友？
这似乎是你写它的方式是不可能的。 解决方案可能是根本不让他们成为朋友。

Answer 4

您不转发声明成员 function，您转发声明 class。

class B;  // DECLARE class B but don't define its contents

class A { // ... uses B as above
};

class B { // ... now you define the class.
};

请参阅C++ 常见问题解答第 39 节。