1

我必须处理 type 的单个对象InternalMessage，将每个对象转换为一定数量的ExternalMessage对象（InternalMessages 和 ExternalMessages 之间存在一对多的关系），并将这些ExternalMessage对象放入队列中进行处理。我想有两种插入到这个队列的模式 - 批处理，所有的ExternalMessage都被原子地插入到队列中，以及正常插入，其中ExternalMessage对象在创建时被插入到队列中。请注意，有多个线程为此队列生成消息。

我解决这个问题的想法是有一个Inserter对象来处理插入：

class Inserter {
public:
    void ProcessMessage(const ExternalMessage& externalMessage) = 0;
};

class SingleInserter {
public:
    SingleInserter(Queue* q) : m_q(q) { }
    void ProcessMessage(const ExternalMessage& externalMessage) {
        m_q->Insert(q);
    }
private:
    Queue* m_q;
};

class BatchInserter {
public:
    BatchInserter(Queue* q) : m_q(q) { }
    void ProcessMessage(const ExternalMessage& externalMessage) {
        m_cache.Insert(externalMessage);
    }
    ~BatchInserter() {
        m_q->BatchInsert(m_cache);
    }

private:
    Queue* m_q;
    List<ExternalMessages> m_cache;
};

然后在Inserter创建消息时向下传递调用堆栈。

BatchInserter ins;

或者

SingleInserter ins;

接着

HandleMessage(someInternalMessage, ins);

和 HandleMessage 会做：

void HandleMessage(const InternalMessage& msg, Inserter& ins) {
    //... do logic, eventually create a externalMsg (note - this could be further down
    //the call stack, in a loop, etc. Multiple external messages could be created each
    //call to HandleMessage)
    ins.ProcessMessage(externalMsg);
}

这种设计理想吗？很高兴它允许不同的插入类型，但是有什么方法可以做到这一点而不必将对象向下传递到调用堆栈（例如，通过模板特化）？其次，在实现这一点时我应该遵守一个 STL 模式吗？

4

1 回答 1

2

在我看来没问题。我能想到的唯一改变就是制作HandleMessage模板。所以你会有template <class T> HandleMessage(const InternalMessage& msg, T& inserter). 有了这个，你就不会强迫这个类的用户从抽象基类派生，Inserter并且会避免由于虚函数引起的动态调度造成的小开销。

于 2012-05-14T04:10:31.710 回答