0

我的程序需要像这样运行：

./myprogram inputType [Can be I1, I2 or I3]

该程序的大部分功能如下：

void Foo::foo (IType inputType) {
    // Some common code
    if (inputType == I1) ... // some I1 specific code
    if (inputType == I2) ... // Some I2 specific code
    ...// similarly for I3
}

这些对 inputType 的检查分散在多个地方，并且随着时间的推移变得越来越难以管理。我曾想过将此代码重构为：

InputType* iType = new InputTypeI1(); // or I2 or I3

void Foo::foo (IType inputType) {
    // Some common code
    iType.DoSomething(this, arg1, arg2,..)
}

class InputType1 : public InputType 
{
     // Virtual functions.. (with default implementations)
}

InputType1::DoSomething(Foo* f, Arg1* arg1, Arg2* arg2)
{
    f->DoSomethingFor1(arg1, arg2);
}

这导致为 I1、I2 或 I3 组织事物，并根据输入类型自动调用相关函数。但是，我觉得这可以做得更好。有什么建议么？

4

2 回答 2

1

很难从您提供的代码段中分辨出来，但我会考虑拥有三个派生的 foo 类，FooI1、FooI2 和 FooI3，并使用基于 InputType 的工厂构建适当的类。

然后所有的特化只是在每个新类的虚拟方法中实现。

class FooI1: public Foo {
 void doSomething() {...};
}

I2/I3 同上。

Foo * fooFactory(InputType iType) 
{ 
   return new FooX - depending on iType
};
Foo *f = fooFactory(i)

f->doSomething();
于 2013-01-21T10:44:15.233 回答
1

您当前的代码将 Foo 和 InputType 结合起来：

  1. Foo creates InputType Object
  2. InputType calls Foo function

建议的解决方案是：

 1. Decouple InputType and Foo by using composites mode
    Foo could hold a pointer to `InputType*` then call InputType `virtual` function.    
 2. To make InputType, a factory will simple enough.

示例代码：

class InputType
{
 public:
    virtual ~InputType();
    virtual void DoSomething();
};

InputType* MakeInputObject(const IType& inputType)
{
   return new InputTypeX; 
}

class Foo
{
public:
  Foo(const InputType& input) : input_type_ptr(MakeINputObject(input) {} 
  void DoSomething() { input_type_ptr->DoSomeThing(); }

private:
  std::unique_ptr<InputType> input_type_ptr;
};
于 2013-01-21T10:53:01.103 回答