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

您可以使用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（接口隔离原理）和DIP（依赖性反转原理）。

在一堆类

1 个答案: