运算符 +/- 在 C++ 中作为非成员函数重载

Question

所以我写了一些实现这个层次结构的代码：

class A 
{
    int x;
    int y;
public:
    A ()  { }
    void setX(int x) { this->x = x;}
    void setY(int y) { this->y = y;}    
    int getX(void) { return x;}
    int getY(void) { return y;}    
    virtual int somefunc() = 0;
    friend B operator- ( B b1, B b2);
};    

class B : public A
{
    int somefunc() {return 0;}
};

class C : public A
{
    int somefunc() {return 1;}  
};

class D : public C
{
    int somefunc() {return 2;}
};
/*
// 1 st attempt - fail
A operator- (const A& a_inst, const A& a_inst2)
{
    A a_temp; 
    a_temp.setX( a_inst.getX() - a_inst2.getX() );
    a_temp.setY( a_inst.getY() - a_inst2.getY() );    
    return a_temp;  
}

// 2nd attempt - FAIL
const A* operator- (const A* a1, const A* a2)
{
    a1.setX( a1.getX() - a2.getX() );
    a1.setY( a1.getY() - a2.getY() );
    return a1;
}
//*/


//3rd  attempt
B operator- ( B b1, B b2)
{
    int temp1x =  b1.getX();
    int temp2x = b2.getX();
    b1.setX( temp1x - temp2x );

    int temp1y =  b1.getY();
    int temp2y = b2.getY();
    b2.setY( temp1y - temp2y );
    return b1;
}



 int main()
{
    B b();
    C c();

    b = b - dynamic_cast<B*>(c) ;
}

我明白因为 A 是抽象的 class 它不能被实例化，所以我不能用 Class A 实例来做。

是否可以重载 +/- 一次（每个）并使其应用于该层次结构中属于 class 的每个实例？我还想指出，我希望能够同时对不同 classes 的对象做同样的事情，如下所示：

C c;
B b;
b = b - c;

编辑 1~ 添加了我目前正在尝试开始工作的第二个版本的重载。

编辑 2~ 更正了 setter 的错误调用

编辑 3~ 添加了第三个版本，仍然出现错误

Answer 1

您的代码存在一些问题： 1. 指定继承类型：public

class B : public A {
    ...
}

2。 B运算符- (const B& a_inst, const B& a_inst2)

{
    B a_temp; 
    a_temp.setX() = a.getX() - a_inst2.getX();
    a_temp.setY() = a.getY() - a_inst2.getY();

    return a_temp;  
}

你不能那样使用，因为 setX 和 setY returns 值不是指针或引用。

运算符 +/- 在 C++ 中作为非成员函数重载

Operator +/- overloading as a non member function in C++

c++

overloading

operator-overloading