既然可以使用函数引用，为什么还要使用函子呢

Why use a functor when you can use a function reference

本文关键字：可以使 函数 引用 为什么      更新时间：2023-10-16

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

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垃圾。

在您的示例中，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;
  }
};

如果你知道工厂里不需要当地州，那么选择更简单的格式更好。

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

方法指针也可以这样做，但您必须将方法指针和传递给要调用该方法的对象。

使用函子，您只需要传递对象，这通常更可读。

相关文章：