Question

我已经阅读了有关该主题的几个问题，但仍然很难得出结论。如果这是一个多余的问题，我会提前道歉。

为了达到目的，我的问题是尝试实施逻辑支付测试。例如，金融产品可能有几个条件，并且根据每个条件，收益会有所不同。但是，在收到合同之前，有多少条件是未知的。目标是对付款实施进行编程，而不是在新产品到来时对每个if语句进行硬编码。例如，我首先收到的只有一个条件的合同。第二天我收到了一份有两个条件等的合同。我明白这个问题可以通过多态来解决，但我很难过。

支付本身使用多态进行编码。

例如，我有一个具有具体通用支付类的抽象通用支付类。

class cPayoffAbstract
{
private:
public:
   cPayoffAbstract(){}
   virtual cPayoffAbstract* clone() const = 0;
   virtual ~cPayoffAbstract(){} 
   virtual double operator()(double& x) const = 0;
};

class cPayoffConcrete1 : public cPayoffAbstract
{
private:
   double y;
public:
   cPayoffConcrete1(double& argY);
   virtual cPayoffConcrete1* clone() const;
   virtual ~cPayoffConcrete1(){}
   virtual double operator()(double& x) const;
};

class cPayoffConcrete2 : public cPayoffAbstract
{
private:
   double y;
public:
   cPayoffConcrete2(double& argY);
   virtual cPayoffConcrete2* clone() const;
   virtual ~cPayoffConcrete2(){}
   virtual double operator()(double& x) const;
};

然后我有另一个类来定义更复杂的收益的界面。

#include <cPayoffAbstract.h>
#include <SmartPtr.h>
#include <vector>
class cConditionalPayoff
{
private:
   // Some data members
public:
   cConditionalPayoff(const SmartPtr<cPayoffAbstract>& argPayoffPtr1, const SmartPtr<cPayoffAbstract>& argPayoffPtr2);

   // some methods ...
   double fConditionalPayoff(const std::vector<double>& argXs, double& argY, double& argZ) const;
};

假设存在一个条件很少的合同，并且根据条件将在通用支付类中实现不同的支付。

double cConditionalPayoff::fConditionalPayoff(const std::vector<double>& argXs, double& argY, double& argZ) const
{
   for (unsigned long i = 0; i < argXs.size(); i++)
   {
      if (argXs[i] > argY) { return dmPayoffPtr1->operator()(argXs[i]); }
      else
      {
          if (argXs[i] < argZ) { return dmPayoffPtr2->operator()(argXs[i]); }
          else { return argX[i]; }
      }
   }
}

问题出现在例如具有类似收益但在合同中设计了更多条件的不同合同时。然后必须重新编码上述if语句，或者必须实现另一种方法。

因此，目标是以动态的方式实现fConditionalPayoff，而不是在ad hoc中编码。

我希望我的重新编辑有助于澄清一些误解。如果有，我道歉。

再次感谢你。

Answer 1

也许您可以将逻辑拆分为两部分（伪代码）：

class PayOffProcessor;

class PayOffProcessor1 : public PayOffProcessor { ... };
class PayOffProcessor2 : public PayOffProcessor { ... };
class PayOffProcessor3 : public PayOffProcessor { ... };

class PayOffProcessor
{
    virtual void process() = 0;

    static PayOffProcessor * processorForData(double x, double y, double z)
    {
        static PayOffProcessor1 processor1;
        static PayOffProcessor2 processor2;
        static PayOffProcessor3 processor3;
        if (x > y)
        {
            return &processor1;
        }
        if (x < z)
        {
            return &processor2;
        }
        return &processor3;
    }
};

double myclass::conditionalPayoff(std::vector<double>& x, double& y, double& z) const
{
     for (unsigned long i = 0; i < x.size(); i++)
     {
         processorForData(x, y, z)->process();
     }
}

Answer 2

我对您的问题的理解是您希望动态地向Contract对象添加行为。在这种情况下，我认为你需要的是装饰模式。

您可以在此处找到其说明：http://www.oodesign.com/decorator-pattern.html

以及此处的一些解释：http://oreilly.com/catalog/hfdesignpat/chapter/ch03.pdf

Answer 3

如果您了解条件的所有可能组合，则只能应用多态性，因此您可以从每个条件的抽象类派生，并为这些条件实现检查功能。

如果您不知道可能的条件，则应通过用户输入或其他任何方式来定义它们。您可以像下面这样处理：

Input: Vector<Values>, Vector<ConditionType>, Vector<ConditionValue>, Vector<PayOffType>

在ConditionType Vector中你写了......像一串“＆lt;”或“＆gt;”或某事。

void checkConditions(vector<double> values, vector<string> condType, vector<double> condValues, vector<string/int> PayOfftype) {
  for(int i=0; i<values.size(); i++) {
    switch(condType[i]) {
      case("<"):
        if(values[i] < condValues[i]) {
           PayOff po = getPayOffByType(PayOfftype[i]);
           po.payoff();
        }
        break;
      case(">"):
        ...
      break;
      ...
    }
  }
}

如果没有条件适用，您可以将此默认支付类型转换为此。

在c ++中将多个if-else语句转换为多态

3 个答案: