C++ 重载运算符=在类之间交换数据

对于一些不同类型的任务，我想使用两个类

A

和

B

。但是我想交换一些数据，这两个数据应该是相似的，所以我想用a

a=B
来表示ex

那么，如何使用它，避免双向包含在头文件中

例如：
在a.h类中：

#include class_b.h
class A {
  private:
    int i;
  public:
    A& operator=(B& const b);
}

h类：

#include class_a.h // won't work here ...
class B {
  private:
    unsigned long n;
  public:
    B& operator=(A& const a);
}

您必须向前声明另一个类：

class B;
class A {
  private:
    int i;
  public:
    A& operator=(B& const b);
}

还要注意，您可能应该声明
友元类BA
的定义中，如果您没有getter并且需要访问
B:：n
您必须向前声明另一个类：

class B;
class A {
  private:
    int i;
  public:
    A& operator=(B& const b);
}

还要注意，您可能应该声明
友元类BA
的定义中，如果您没有getter并且需要访问
B:：n
您需要使用转发声明：

class A;

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

您需要使用转发声明：

class A;

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

不一定更好，但也要考虑不要重写赋值，但要提供转换。
你可以像我一样

#include "b.h"
class A
{
public:
    A(const B&);
    operator B() const;
};

如果你做了
a=b它将隐式地变成
a=a（b）
，如果你这样做
b=a将隐式变成
b=a.operator b（）

这就像说B可以“升级”到A，A可以“降级”到B。
但是你可以做一个A，而不是修改B.
不一定更好，但是也要考虑不要重写赋值，而是提供转换。
你可以像我一样
#include "b.h"
class A
{
public:
    A(const B&);
    operator B() const;
};

如果你做了
a=b它将隐式地变成
a=a（b）
，如果你这样做
b=a将隐式变成
b=a.operator b（）

这就像说B可以“升级”到A，A可以“降级”到B。
但是您可以围绕A执行所有操作，而不是修改B。
为什么它们需要在不同的头文件中？为什么它们需要在不同的头文件中？