如果从同一基类相互作用的两个不同的派生类对象，如何提出异常？

Question

我有一个带有A＆amp;的抽象基类（x） B派生的类。

我在X中有一个类方法，该方法由两个类A＆amp; B.

我希望该方法能够引发异常，如果两个不同的派生类对象相互交互。

这是一个人为的例子：

class Food{
    public:
        int count;
        void combine(Food* a) {
            this->count += a->count;
        }
};


class Orange : Food {
    public:
        Orange(int x) {
            count = x;
        }
};

class Apple : Food{
    public:
        Apple(int x) {
            count = x;
        }
};


int main() {
    Food* basket_apples = new Apple(5);
    Food* basket_oranges = new Orange(4);
    Food* crate_oranges = new Orange(10);
    crate_oranges.combine(basket_oranges);//should work fine
    crate_oranges.combine(basket_apples); //should produce error
}

我考虑的解决方案是覆盖两个派生类中的联合方法，但这违反了干燥（不要重复自己）。

我想知道是否还有其他选择可以解决此问题。

Answer 1

您可以在组合函数中检查一下：

void combine(Food const& a) // You should pass your argument by const ref
{
    assert(typeid(*this) == typeid(a)); // This checks ONLY IN DEBUG !
    this->count += a.count;
}

如果要管理错误，使用异常或返回值：

void combine(Food const& a)
{
    if(typeid(*this) != typeid(a))
      throw std::runtime_error("Invalid combined types");
    this->count += a.count;
}


int combine(Food const& a)
{
    if(typeid(*this) != typeid(a))
      return 1;
    this->count += a.count;
    return 0;
}

也许您应该转移计数器？

void combine(Food& a) // Passing by non-const reference
{
    assert(typeid(*this) == typeid(a));
    this->count += a.count;
    a.count = 0;
}

注意：如用户17732522所说，您的成员函数组合应该是虚拟的，并且类应该更好地管理继承。我建议这样做：

class Food
{
    protected:
        std::size_t count; // You want this value >= 0
    public:
        Food(std::size_t count_) : count(count_) {}
        Food(Food const& f) : count(f.count) {}
        virtual ~Food() {}
        virtual std::string name() const = 0;
        virtual void combine(Food const& a)
        {
            assert(typeid(a) == typeid(*this));
            this->count += a.count;
        }
};


class Orange : public Food
{
    public:
        Orange(std::size_t x) : Food(x) {}
        Orange(Orange const& o) : Food(o) {}
        virtual ~Orange() {}
        virtual std::string name() const { return "orange"; }
};

class Apple : public Food
{
    public:
        Apple(std::size_t x) : Food(x) {}
        Apple(Apple const& a) : Food(a) {}
        virtual ~Apple() {}
        virtual std::string name() const { return "apple"; }
};