0

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

直截了当，我的问题是尝试实施一个合乎逻辑的回报测试。例如，一种金融产品可能有几个条件，并且根据每个条件，收益会有所不同。但是，在收到合同之前，尚不清楚有多少条件。目标是编写一个回报实现，而不是在新产品出现时对每个 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动态方式实现，而不是在 ifs ad hoc 中进行编码。

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

再次感谢你。

4

3 回答 3

0

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

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();
     }
}
于 2013-11-04T13:30:33.880 回答
0

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

你可以在这里找到它的描述：http ://www.oodesign.com/decorator-pattern.html

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

于 2013-11-04T13:35:15.933 回答
0

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

如果您不知道哪些条件是可能的，则它们应该由用户输入或其他定义。你可以这样处理：

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

在 ConditionType Vector 中，您编写某事。比如一串“<”或“>”之类的。

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;
      ...
    }
  }
}

如果不适用任何条件，您可以将默认支付类型传递给此。

于 2013-11-04T15:19:28.853 回答