c++ 重载虚+运算符

Question

#include <iostream>

class aa
{
public:
    aa(){}

    aa(aa& obj)
    {
        aa1 = obj.aa1;
    }

    virtual aa operator =(aa& obj)
    {
        aa1 = obj.aa1;
        return (*this);
    }

    virtual aa operator +(aa& obj)
    {
        aa1 += obj.aa1;
        return (*this);
    }

    int aa1;
};

class bb: public aa
{
public:
    bb():aa(){}

    bb(bb& obj)
    {
        bb1 = obj.bb1;
    }

    aa operator =(aa& obj)
    {
        aa::operator =(obj);
        bb b1 = dynamic_cast<bb&>(obj);
        bb1 = b1.bb1;       
        return (*this);
    }

    aa operator +(aa& obj)
    {
        aa::operator +(obj);
        bb b1 = dynamic_cast<bb&>(obj);
        bb1 += b1.bb1;
        return (*this);
    }

    int bb1;
};


int main()
{
    bb b1;
    bb b2;

    b1.bb1 = 1;
    b1.aa1 = 1;

    b2.bb1 = 2;
    b2.aa1 = 2;

    aa &a1 = b1;
    aa &a2 = b2;

    a1 = a2;
    b1 = dynamic_cast<bb&>(a1);
    b2 = dynamic_cast<bb&>(a2);

    std::cout<<b1.aa1<<";"<<b1.bb1;

    bb b3;
    b3.bb1 = 3;
    b3.aa1 = 3;

    aa &a3 = b3;

    aa &a4 = a2 + a3;
    b3 = dynamic_cast<bb&>(a4);

    return 0;
}

输出： 2;2 然后它在b3 = dynamic_cast<bb&>(a4); 行崩溃，给出错误std::bad_cast at memory location 0x0012fdbc..

我发现的原因是 a2+a3 的表达式结果是 aa 类型的对象，在下一个语句中，我们试图将其强制转换为无效的派生类型对象，从而导致异常。所以我的问题是我们能否通过对上述功能进行一些更改来实现上述意图，即aa &a4 = a2 + a3;？

Answer 1

C++ 有一个分派（基于虚函数）。 多态二元运算符不可避免地陷入“双重调度”的情况，因此不能仅通过简单的虚函数实现多态。

此外，由于您正在返回一个值，因此每个子类信息都会丢失。

处理这种情况的更合适的方法是定义一个非多态句柄来实现操作并保存多态类型，将操作执行委托给它们。

喜欢

class handle
{
public:
    class aa;
    class bb;

    class root
    {
    public:
        virtual ~root() {}         //< required being this polymorphic
        virtual root* clone()=0;

        virtual handle add_invoke(const root& r) const=0; //resolve the 2nd argument
        virtual handle add(const aa& a) const=0;    //resolve the 1st argument
        virtual handle add(const bb& a) const=0;    //resolve the 1st argument
    };

    class aa: public root
    {
    public:
        aa(...) { /*set vith a value */ }
        aa(const aa& a) { /* copy */ }
        virtual root* clone() { return new aa(*this); }

        virtual handle add_invoke(const root& r) const 
        { return r.add(*this); }  //will call add(const aa&);

        virtual handle add(const aa& a) const
        { return handle(new aa(.../*new value for aa with (aa,aa)*/)); }
        virtual handle add(const bb& a) const
        { return handle(new bb(.../*new value for bb with(aa,bb)*/)); }
    };

    class bb: public root
    {
    public:
        bb(...) { /*set vith a value */ }
        bb(const bb& b) { /* copy */ }
        virtual root* clone() { return new bb(*this); }

        virtual handle add_invoke(const root& r) const
        { return r.add(*this); }  //will call add(const bb&);

        virtual handle add(const aa& a) const
        { return handle(new bb(.../*new value for aa with (bb,aa)*/)); }
        virtual handle add(const bb& a) const
        { return handle(new bb(.../*new value for bb with (bb,bb)*/)); }
    };

    handle() :ps() {}
    //support both copy (by clone) and move (by stole)
    handle(const handle& s) :ps(s.ps? s.ps->clone(): nullptr) {}
    handle(handle&& s) :ps(s.ps) { s.ps=nullptr; };
    //assign by value, to force temporary assign
    handle& operator=(handle h) { delete ps; ps=h.ps; h.ps=0; return *this; }
    //cleanup
    ~handle() { delete ps; }

    //the operator+
    friend handle operator+(const handle& a, const handle& b)
    { 
        return (b.ps && a.ps)? b.ps->add_invoke(*a.ps): handle(); 
        //Note: manage also the a+b with one of `a` or `b` as null, if it make sense
    }

private:
    handle(root* p) :ps(p) {}

    root* ps;
};

Answer 2

在派生类中重载aa operator +(aa& obj) 意义不大。

即使是虚拟的，您现在也会随时调用返回 aa 的方法，因此 a2 + a3 的结果将是一个 aa 对象，而不是 bb 对象。它被构造为 bb 对象，但被复制到生成的 aaobject 中，并且副本丢失了 bb 信息。

您应该做的是覆盖bb operator +(const bb& obj) 的特定版本，但请注意，这将隐藏aa 参数的原始operator+，因此您仍然必须重新定义它或使用the using statement 导入。

现在，这些是更好的语义，但它不能解决您的问题，因为在您的情况下，它仍然会调用返回 aa 对象的 operator+。在这种情况下，如果你真的想解决这个问题，你应该在添加 a2和a3之前向下转换。

但实际上，如果您在具有虚拟化功能的父子系统中执行此类操作，您可能会重新考虑您的设计。通常，在任何情况下使用dynamic_cast 都会引起一些注意。它当然有其用途，但应尽可能避免再次向下转换。

Answer 3

您正在传递一个基类，为什么要将它转换为派生转换？您应该从强制转换中捕获异常，因为这样您才能知道类型不是您所期望的。

请注意，虽然 a1 和 a2 引用了 bb 的实例，但 a4 不是。这就是前两次强制转换没有抛出异常的原因。