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是一个抽象类，因此无法实例化，因此我无法使用A类实例。

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

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

编辑1~添加了我目前正在努力工作的第二版重载。

编辑2~纠正了设置者的错误调用

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

Answer 1

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

class B : public A {
    ...
}

2。 B运算符 - （const B＆amp; a_inst，const B＆amp; 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返回的值不是指针或引用。

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

1 个答案: