c++ - 从基类指针派生类方法 : some alternatives?

Question

我知道这类问题已经回答过几次，但我给出了问题的上下文以期待一些其他的架构替代方案。

考虑一个 CExpression 类:

class CExpression
{
    public:
        ...
    private:
        vector<CComponent*> components_;
        string expression_;
}

CExpression 必须将表示数学表达式(例如“y = x + 5”)的字符串分解为 vector (“y”、“=”、“x”、“+”、5)。为此， vector 由 CComponent 指针组成，这些指针可以指向类 CVariable、COperator 和 CConstant 的对象。显然，CComponent是一个抽象类，是上述三个类的基类。因此，在解析字符串后， vector 应按顺序包含以下内容(过程的半伪代码):

components_.push_back(new CVariable("y"));
components_.push_back(new COperator('='));
components_.push_back(new CVariable("x"));
components_.push_back(new COperator('+'));
components_.push_back(new CConstant( 5 ));

这里使用多态性是为了将表达式分解为单个 vector (这将有助于以后的解析过程)。但是，某些派生类具有其他类所没有的独特功能，因此无法在基类 (CComponent) 中实现这些功能。

例如，考虑 COperator 类:

class COperator : public CComponent
{
    public:
        int GetPriority() const { return prority_; }
        ...
    private:
        int priority_;
        ...
}

Priority，表示必须从 vector 中解析运算符的优先级，对于此类是唯一的(因此基类中没有虚函数)。现在让我们来解决问题。

考虑 CComponent 类(基类):

enum Type { VARIABLE, OPERATOR, CONSTANT };

class CComponent
{
    public:
        Type GetType() const { return type_; }
        ...
    private:
        Type type_;
        ...
}

类型，对于表达式的任何组件都是通用的，表示组件的类型(例如，如果它是一个 CVariable，则该类型将在构造时设置为 VARIABLE)。

最后，考虑这个 CExpression 方法(虚构的):

void CExpression::Process()
{
    for (int i = 0; i < components_.size(); i++)
    {
        if (components_[i] -> GetType() == OPERATOR)
        {
            cout << components_[i] -> GetPriority(); // won't work
        }
    }
}

事实上，由于我只能使用指针类型类的方法(除非我使用dynamic_cast，我认为这不是最漂亮的方式)，我有两个问题:

1. 是否有合适的方法来实现我想要实现的目标，或者 dynamic_cast 是我唯一的选择？
2. 我应该采用完全不同的程序架构来解决这个问题吗？如果是，我该怎么办？

顺便说一下，我知道解释起来可能更简单，但我认为上下文会是捕获问题的好 helper 。

谢谢!

Answer 1

我想，您的架构无法满足您的需求 - 特别是当您开始扩展它时。

我在处理数学表达式方面有一些经验，我会说，存储表达式的最自然方式是树。每个终端项(例如数字或变量)是树的叶子，每个非终端项(例如运算符或函数调用)是一个节点，它有子节点。例如:

y = x + 5

应该翻译成树:

  =
 / \
y   +
   / \
  x   5

这样的结构有什么好处？首先，它比标记 vector 更容易评估。其次，诸如运算符优先级或关联方向之类的东西仅在构建此结构时才重要——在构建结构并准备好进行评估时不会使用它们。然后，每个节点都不关心作为子节点附加到它的是什么，它只是让它们评估自己，完成后它最终会得到一个它可以工作的终端项目列表。甚至赋值运算符也可以执行它的工作(当然，如果您向它传递某种包含变量列表的上下文)。

如果使用著名的反向波兰表示法算法，创建这样的结构非常容易。

在你的情况下，我会投票赞成将你的数据结构完全重新排列为一个，这对于存储表达式来说要好得多。

还有一件事。另外，根据我的经验，我强烈建议您为这三件事创建不同的类:

• 从输入中读取的项目(= token )
• 表达式树中的一个项目(= 一个表达式项目)
• 在评估树时作为部分结果的项目(= eval 对象)

这似乎会使您的架构复杂化，但实际上会简化您的工作并让您的架构更加灵活。

结构的草稿:

class BaseNode
{
public:
    virtual EvalObject Eval() = 0;

    // This method is handy when working with assignment operator.
    // For instance, Eval() called on variable will return its value
    // but EvalLHS() will return a reference to variable. 
    virtual EvalObject EvalLHS() = 0;
};

class Operator : BaseNode
{

};

class BinaryOperator : Operator
{
private:
    BaseNode * leftChild;
    BaseNode * rightChild;
};

class Add : BinaryOperator
{
public:
    void Eval()
    {
        auto left = leftChild->Eval(); // Eval RHS, 
        auto right = rightChild->Eval(); // Eval RHS

        // Now perform calculations on left and right
        // depending on their types
    }

    void EvalLHS()
    {
        throw InvalidOperationException("Cannot perform LHS evaluation on adding operator");
    }
}

class Assign : BinaryOperator
{
public:
    void Eval()
    {
        auto left = leftChild->EvalLHS();
        auto right = rightChild->Eval();

        // Perform assignment

        // This is required such that operations
        // like a = b = 7 will also work
        return right;
    }

    void EvalLHS()
    {
        // Assignment cannot be on the LHS of operation, eg.
        // (a = 5) = 8 is wrong

        throw InvalidOperationException("Assignment cannot be LHS");
    }
}