虚拟方法开销是否显著

我有一些复杂的继承结构，主要是为了避免代码重复和方便各种类的通用接口。它依赖于虚拟和非虚拟继承，看起来或多或少是这样的：

class AbstractItem
{
   //bunch of abstract methods
};
class AbstractNode : virtual public AbstractItem
{
    //some more virtual abstract methods
};
class AbstractEdge : virtual public AbstractItem
{
    //yet some different virtual abstract methods
};

然后是一些像这样的"真实"类

class Item : virtual public AbstractItem
{
    //implements AbstractItem
};
class Node : public Item, public AbstractNode
{
    //implements AbstractNode
};
class Edge : public Item, public AbstractEdge
{
    //implemetns AbstractEdge
};

并将其打包到一个图形模型类中，以便：

class AbstractGraph
{
    virtual QList<AbstractNode*> nodes() const = 0;
    virtual QList<AbstractEdge*> edges() const = 0;
};
class GraphModel : public AbstractGraph
{
public:
    virtual QList<AbstractNode*> nodes() const override; //this converts m_Nodes to a list of AbstractNode*
    virtual QList<AbstractEdge*> edges() const override; //dtto
private:
    QList<Node*> m_Nodes;
    QList<Edge*> m_Edge;
};

这种复杂结构的原因是，有不同的类实现AbstractGraph，如排序模型、过滤，这些类有不同的变体-有些类按照所示的模型存储数据，并有自己的AbstractItem/Node/Edge派生类集，另一些类是动态的，依赖于底层图/模型的数据，而没有自己的数据。示例：

class FilterNode : public AbstractNode
{
    //access the data in the m_Item via AbstractItem interface and implements differently AbstractNode interface
private:
    AbstractItem *m_Item = nullptr; //this variable holds pointer to some real item with actual data such as the one from GraphModel
};
class GraphFilter : public AbstractGraph
{
    //implements the interface differently to the GraphModel
private:
    QList<FilterNode*> m_Nodes;
    AbstractGraph *m_Source = nullptr; //source graph...
};

我对此有了第二个想法，因为它依赖于（虚拟）继承，依赖于通过base等调用的抽象方法。由此产生的开销有那么大吗

另一种选择是：

a） 复制粘贴大量代码以避免虚拟方法和大部分继承，但这将是代码维护的噩梦。再加上没有通用接口。。。

b） 以某种方式将其全部模板化。。。我有点不确定，甚至不知道这是否可能。为了避免代码重复，我已经在其中的一些地方使用了它们。

那么，这看起来合理吗？还是有些过头了？我可能会补充说，在某些情况下，我会绕过虚拟调用直接调用方法（在模型内部），但在外部，它几乎总是通过抽象库进行调用。