Question

例如，假设您想要进行工厂模式。为什么这样做：

class IFooFactory {
public:
 virtual ~IFooFactory() {}
 virtual std::unique_ptr<IFoo> operator()(int bar, int baz) const = 0;
};

class AFactory : public IFooFactory {
public:
 virtual std::unique_ptr<IFoo> operator()(int bar, int baz) const override {
  std::unique_ptr<IFoo> a(new A(bar, baz));
  return a;
 }
};

class BFactory : public IFooFactory {
public:
 virtual std::unique_ptr<IFoo> operator()(int bar, int baz) const override {
  std::unique_ptr<IFoo> b(new B(bar, baz));
  return b;
 }
};

void doStuff() {
 std::unique_ptr<IFooFactory> fooFactory(new BFactory);
 doMoreStuff(fooFactory);
}

当你可以这样做时：

typedef std::unique_ptr<IFoo> (&FooFactory)(int bar, int baz);

std::unique_ptr<IFoo> AFactory(int bar, int baz) {
 std::unique_ptr<IFoo> a(new A(bar, baz));
 return a;
}

std::unique_ptr<IFoo> BFactory(int bar, int baz) {
 std::unique_ptr<IFoo> b(new B(bar, baz));
 return b;
}

void doStuff() {
 doMoreStuff(BFactory);
}

第一种解决方案有哪些优势？对我来说，它看起来像是一个令人费解的OO垃圾。

Answer 1

在您的示例中，AFactory和BFactory都不使用本地状态。例如，创建B可能需要为工厂的构造函数提供额外的参数，第二个解决方案会遇到问题：

class BFactory : public IFooFactory {
  int zoo;
public:
  BFactory(int zoo): zoo(zoo) {}
  virtual std::unique_ptr<IFoo> operator()(int bar, int baz) const override {
    std::unique_ptr<IFoo> b(new B(bar, baz, zoo));
    return b;
  }
};

如果您知道工厂不需要本地州，那么更简单的格式更好。

Answer 2

使用仿函数意味着你会在对象（某个类的实际实例）上调用方法，而不是调用一个没有上下文的简单函数。这意味着调用的结果可能由对象的状态决定。

使用方法指针也可以这样做，但是你必须传递方法指针和调用方法的对象。

使用仿函数，您只需要传递通常更具可读性的对象。

为什么在使用函数引用时使用仿函数

2 个答案: