在堆栈之间交换数据

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 };
}

它们的目的是处理data并将其向较低或较高的方向移动（类设计可能是错误的，仅出于构思目的）。 例如，用于网络协议栈抽象。

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

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

Answer 1

您可以使用策略模式 。

在您的示例中，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（接口隔离原理）和DIP（依赖关系反转原理）。