Question

我正在开发一些复杂的计算，需要确定“步骤”（策略模式类型实现），而且我不确定将步骤子计算类注入主类的最佳方法。

我研究过基于策略的设计但是阅读策略设计是针对'编译时多态'而不是运行时。另外，我不知道如何使用模板，因为一些子计算类需要构造函数参数。

我已经开始为每个步骤实现虚拟“接口”类，并在构造函数中将每个步骤作为unique_ptr注入，但不确定这是否是正确的“现代C ++”方式。

我最初开始实现主类中的所有功能，但发现这使得很难（如果不是不可能）独立地对每个步骤进行单元测试。

结构类似于以下内容：

class CalculationStepA
{
public:
  // default constructor

  StepAResult performStep(const input& requiredInput);
};

class CalculationStepBType1
{
public:
  // default constructor

  StepBResult performStepB(const stepBInput& requiredInput);
};

class CalculationStepBType2
{
public:
  CalculationStepBType2(const inputIOnlyNeedForType2& parameters)
  {
    // initialize class members from input
    // need for this calculation type
  }

  StepBResult performStepB(const stepBInput& requiredInput);
};

class CalculationStepCType1
{
public:
  CalculationStepBType2(const inputIOnlyNeedForType1& parameters)
  {
    // initialize class members from input
    // need for this calculation type
  }

  StepCResult performStepC(const stepCInput& requiredInput);
};

class CalculationStepCType2
{
public:
  CalculationStepBType2(const inputIOnlyNeedForType2& parameters)
  {
    // initialize class members from input
    // need for this calculation type
  }

  StepCResult performStepB(const stepCInput& requiredInput);
};

class ClassThatUsesAllTheCalculations
{
public:
  ClassThatUsesAllTheCalculations(/* take required parameters that determine which step types I need */)
  {}

  // possible constructor?
  ClassThatUsesAllTheCalculations(
       std::unique_ptr<IStepACalculationStrategy> stepA, 
       std::unique_ptr<IStepBCalculationStrategy> stepB,    
      std::unique_ptr<IStepCCalculationStrategy> stepC)
  {

  }

  FinalResult executeCalculation(const finalInputRequiredHere& input)
  {
    auto stepAresult = stepACalculator(somethingFromInput);
    // logic to use stepA and determine if we should continue

    auto stepBresult = stepBCalculator(somethingFromStepAResult);
    // again, logic to use stepB and determine if we should continue

    auto stepCresult = stepCCalculator(somethingFromStepBResult);
    // assemble final result

    return theFinalResult
  }


  // other method needed to setup calculation


private:
  TypeForStepACalculation stepACalculator;
  TypeForStepBCalculation stepBCalculator;
  TypeForStepCCalculation stepCCalculator;
};

对于确定最佳设计的任何帮助都将非常感激。

Answer 1

关于一个简单的继承是什么？

struct StepA{
    virtual StepAResult perform(StepAParams)=0;
};

struct someStepAImpl : public StepA{
    virtual StepAResult perform(StepAParams params) override {
        //actual implementation
    }
};

您的计算类是否使用引用（在构造中设置），std::reference_wrapper（非空，但稍后可以更改）或某种（智能）指针（可能是{{1不要忘记检查，但最简单的是管理生命周期）取决于您打算如何使用它以及如何管理对象的生命周期。使用nullptr的示例如下：

unique_ptr

C ++通过构造函数

1 个答案: