C++ 基于策略的设计决策

我有一个名为Device的类，据我所知，它接受两个策略：StatePolicy和BehaviorPolicy
状态策略保存并管理设备的状态。
<强> BehaviorPolicy 封装了用C或C++编写的设备驱动程序。 现在我有两个问题：

如何协调国家和行为政策

如何将所有设备存储在一个容器中？由于设备的类型与设备不同，所以我无法将它们存储在一个容器中

编辑1： 下面是一些代码来说明我的问题：

class AbstractDevice
{
public:
  virtual ~AbstractDevice() {}

  virtual void performAction() = 0;
  virtual const string &getName() const = 0;
  //virtual void changeState(const ??? &_state) = 0;  If I put a template here it won't solve my problem
};

template<typename T>
class State
{
private:
  T state;
protected:
  typedef T StateType;
public:
  State() : state(1) {}

  const T &getState() { return state; }
  void setState(const T _state) { state = _state; }
};

template <class StatePolicy>
class LightbulbBehvior : protected StatePolicy
{
private:
  typedef StatePolicy SP;
public:
  virtual void performAction()
  {
    if ( SP::getState() )
      cout << "do stuff";
  }

  void changeState(const typename SP::StateType &_state)
  {
    setState(_state);
    performAction();
  }
};

template<class StatePolicy, template <class> class BehviorPolicy>
class Device : public AbstractDevice, public BehviorPolicy<StatePolicy>
{
private:
  string sName;
public:
  const string &getName() const { return sName; }
};

int main()
{
  AbstractDevice *d = new Device<State<int>, LightbulbBehvior>();
  d->changeState(5);
  return 0;
}

提前感谢，

---

Omer.

我不确定你在第一个问题中的意思。关于第二个，您可以为设备类模板创建DeviceBase类。然后，您可以将指向这个基类的指针存储在容器中

class DeviceBase
{
  //...
};

template <class T1, class T2>
class Device : public DeviceBase
{
  //...
};

类设备库
{
//...
};
模板
类设备：公共设备库
{
//...
};

关于第一个问题：

如何协调国家和行为政策

如果需要协调这两个策略，则它们不是正交的。如果它们不是正交的，它们就不适合您正在进行的设计类型。但是，看看示例代码，我发现您已经有了依赖于状态的行为，所以我不知道这个问题的重点是什么

---

至于第二个问题，它有正确的答案，这也嵌入到您的代码中。如果您正在寻找一种将模板化类保存在通用容器中的方法，那么这是最好的方法。为了克服

changeState

问题，您需要使用一些通用函数来更改状态。。。像

打开

，

关闭

，等等。如果你不能实现这些功能，可能你的代码太通用了。

以下是完整的设计，它可以很好地工作：

class AbstractState
{
public:
  virtual ~AbstractState() {}
};

class AbstractDevice
{
public:
  virtual ~AbstractDevice() {}

  virtual void performAction() = 0;
  virtual const string &getName() const = 0;
  virtual void changeState(const AbstractState &_state) = 0;
};

template<typename T>
class State : public AbstractState
{
private:
  T state;
protected:
  typedef T StateType;
public:
  State() {}
  State(const T _state) : state(_state) {}

  const T &getState() const { return state; }
  void setState(const T _state) { state = _state; }
};

template <class StatePolicy>
class LightbulbBehvior : protected StatePolicy
{
private:
  typedef StatePolicy SP;
public:
  virtual void performAction()
  {
    if ( SP::getState() )
      cout << "do stuff";
  }

  void changeState(const typename SP::StateType &_state)
  {
    setState(_state);
    performAction();
  }
};

template<class StatePolicy, template <class> class BehviorPolicy>
class Device : public AbstractDevice, public BehviorPolicy<StatePolicy>
{
private:
  string sName;

  typedef BehviorPolicy<StatePolicy> BP;
  typedef StatePolicy SP;
public:
  const string &getName() const { return sName; }

  void performAction()
  {
    BP::performAction();
  }

  void changeState(const AbstractState &_state)
  {
    BP::changeState(((const SP &)_state).getState());
  }
};

int main()
{
  AbstractDevice *d = new Device<State<int>, LightbulbBehvior>();
  d->changeState(State<int>(5));
  delete d;
  return 0;
}

类抽象状态
{
公众：
虚拟~AbstractState（）{}
};
类抽象设备
{
公众：
虚拟~AbstractDevice（）{}
虚空性能（）=0；
虚拟常量字符串&getName（）常量=0；
虚拟void changeState（const AbstractState&_state）=0；
};
模板
类状态：公共抽象状态
{
私人：
T状态；
受保护的：
类型定义T状态类型；
公众：
状态（）{}
州（const T_State）：州（_State）{}
const T&getState（）const{return state；}
void setState（const T_state）{state=_state；}
};
模板
类LightbulbBehvior:受保护的状态策略
{
私人：
typedef StatePolicy SP；
公众：
虚空性能（）
{
如果（SP:：getState（））
不能改变状态（状态（5））；
删除d；
返回0；
}

---

@cjhuitt：一般来说，我认为你是对的，但请看一看，然后告诉我你的想法。

我不认为这是基于策略的设计。我认为这只是一个包含多种授权或策略组合的设计决策。但设计是如何表示策略。它不是基于某个策略的设计。我认为这是一个很好的例子我解释了政策和模式的概念是多么容易被误解。我添加了一些代码来澄清我的意思。

class AbstractState
{
public:
  virtual ~AbstractState() {}
};

class AbstractDevice
{
public:
  virtual ~AbstractDevice() {}

  virtual void performAction() = 0;
  virtual const string &getName() const = 0;
  virtual void changeState(const AbstractState &_state) = 0;
};

template<typename T>
class State : public AbstractState
{
private:
  T state;
protected:
  typedef T StateType;
public:
  State() {}
  State(const T _state) : state(_state) {}

  const T &getState() const { return state; }
  void setState(const T _state) { state = _state; }
};

template <class StatePolicy>
class LightbulbBehvior : protected StatePolicy
{
private:
  typedef StatePolicy SP;
public:
  virtual void performAction()
  {
    if ( SP::getState() )
      cout << "do stuff";
  }

  void changeState(const typename SP::StateType &_state)
  {
    setState(_state);
    performAction();
  }
};

template<class StatePolicy, template <class> class BehviorPolicy>
class Device : public AbstractDevice, public BehviorPolicy<StatePolicy>
{
private:
  string sName;

  typedef BehviorPolicy<StatePolicy> BP;
  typedef StatePolicy SP;
public:
  const string &getName() const { return sName; }

  void performAction()
  {
    BP::performAction();
  }

  void changeState(const AbstractState &_state)
  {
    BP::changeState(((const SP &)_state).getState());
  }
};

int main()
{
  AbstractDevice *d = new Device<State<int>, LightbulbBehvior>();
  d->changeState(State<int>(5));
  delete d;
  return 0;
}