假设我们有一堆链接类。伪代码:
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 */
中的参数可以是任何类型,具体取决于当前级别的用途。
您是否知道实现此行为的任何设计模式或编程最佳实践?
最佳答案
您可以使用 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(依赖倒置原则)。
关于c++ - 在类堆栈之间交换数据,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/32182148/