c++ - 在类堆栈之间交换数据

Question

假设我们有一堆链接类。伪代码:

template<class CMyLevelHigher, class CMyLevelLower>
class CMyLevel 
{
public:
    CMyLevel(CMyLevelHigher* t_higher, CMyLevelLower* t_lower)
        :   m_higher(t_higher),
            m_lower(t_lower) 
    {
        // ...
    }

    void ProcessInHigher(/* data */) 
    {
        // ...

        if (m_higher != nullptr) {
            m_higher->ProcessInHigher(/* data */);
        }

        // ...
    }

    void ProcessInLower(/* data */) 
    {
        // ...

        if (m_lower != nullptr) {
            m_lower->ProcessInLower(/* data */);
        }

        // ...
    }

private:
    CMyLevelHigher* m_higher{ nullptr };
    CMyLevelLower* m_lower{ nullptr };
}

它们的目的是处理数据并将它们移动到较低或较高的方向(类设计可能不正确，仅供引用)。例如，对于网络协议(protocol)栈抽象。

/* data */ 中的参数可以是任何类型，具体取决于当前级别的用途。

您是否知道实现此行为的任何设计模式或编程最佳实践？

Answer 1

您可以使用 Strategy Pattern .

在您的示例中，CMyLevelHigher 和 CMyLevelLower 都继承了一个新的基本抽象类 CMyLevelBase，这样

template < typename ARGS >
class CMyLevelBase {
public:
    virtual void Process(const ARGS& args) = 0;
};

struct Args { /* specific parameters */ };
class CMyLevelHigher : public MyLevelBase<Args> { ... };
class CMyLevelLower  : public MyLevelBase<Args> { ... };

template < typename ARGS >
class CMyLevel {
    ...
public:
    void ProcessInHigher(const ARGS& args) { m_higher->ProcessInHigher(args); }
    void ProcessInLower (const ARGS& args) { m_lower ->ProcessInHigher(args); }
private:
    CMyLevelBase<ARGS>* m_higher{ nullptr };
    CMyLevelBase<ARGS>* m_lower { nullptr };
};

通过使用策略模式，CMyLevel 变得独立于 CMyLevelHigher、CMyLevelLower 和 Args。因此本设计实现了ISP(接口(interface)隔离原则)和DIP(依赖倒置原则)。