【问题标题】:How to use the factory pattern with functors?如何将工厂模式与仿函数一起使用?
【发布时间】:2013-03-30 14:19:38
【问题描述】:

我有一组函子,用于计算对象范围内的特定内容。本质上,每个函子都实现了operator():

template <typename Iterator1,
          typename Iterator2> double operator()( Iterator1 it1,
                                                 Iterator2 it2 ) const
{
  return( 0.0 );
}

我现在有一组对象,可以用不同的仿函数创建。我通过模板创建函数解决了这个问题:

template <class Functor> Foo createFoo( ... // some parameters for foo objects
                                        Functor f = Functor() )
{
  // calculate stuff for "foo" using functor "f"
}

我现在想将函子选择委派给我程序的用户,所以我决定创建一个函子工厂。给定一个仿函数的描述性名称,我想创建适当的仿函数,以便它可以用于创建所有Foo 对象,如上所述。

这就是我卡住的地方:我无法创建一个返回模板仿函数的工厂,因为如果不编码我想要创建的确切类型的仿函数,我就无法调用此函数。

我想过让operator() 成为某个基类的虚函数,即FunctorBase,但我不希望与虚函数调用相关的性能开销。避免上述开销是我首先选择使用模板的原因。

我在这里陷入僵局,肯定会感谢一些 cmets。

编辑:

我打算做什么(无效代码):

DistanceFunctor f = createFunctor( "Bar" ); // Create a functor from a client-supplied string

Foo createFoo( ..., // parameters for foo
               f );

在 cmets 中,也建议使用虚函数。但是,如上所述的当前仿函数设计不适用于虚函数,因为编译器无法使函数模板成为虚函数。调整仿函数类以将两种迭代器类型作为模板参数是可能的,但非常笨拙。

编辑:

仿函数的工作方式与 FLANN 中使用的类似。 See the git repository for an example。我看不出如何以不同的方式指定这些函子。

【问题讨论】:

  • 你能说明你打算如何一起使用所有这些功能吗?
  • “性能开销”是否可测量?虚函数调用是否造成如此严重的伤害,即分析器是否告诉您它们是关键的性能瓶颈?或者您是否在进行过早的优化让您的生活变得更加困难?
  • @ArneMertz:我还没有实现其他变体。我想如果每个仿函数都应用于数百万个对象,虚函数可能会减慢我的速度。因此:您可能是对的:-/ 我将实现另一个变体并报告一些结果。
  • @ArneMertz 愚蠢的我:因为每个仿函数都包含一个函数模板,所以我不能使用virtual。至少不是我在这里描述的那样。
  • DistanceFunctor 是做什么的?您提供的第一个签名似乎确实以某种方式从一系列对象或类似的东西中积累了值。也许您不需要遍历范围的函子,而是可以传递给createFoo 并在某些遍历范围的算法中使用它的谓词(例如std::accumulate)。

标签: c++ templates factory functor


【解决方案1】:

考虑过您的要求,这是我想出的第一件事: 您的不同仿函数显然不能以现在定义的方式从公共基类派生,因为您不能使模板化的operator() 虚拟化。但是,如果您将模板参数从运算符推到函子本身,您可以使该运算符为虚拟:

template <class Iterator>
struct Functor {
  virtual double operator()(Iterator it1, Iterator it2) const = 0;
};

这有什么帮助?乍一看在 Functor 级别的模板并不好,因为您现在必须知道 createFunctor 调用之外的参数,事实上,如果您调用它,您将必须显式指定迭代器类型:

//some concrete functors
template <class It>
struct FuncImpl_Bar : Functor<It> { /* ... implement op()(It, It) ... */ }:

template <class It>
struct FuncImpl_Meow : Functor<It> { /* ... implement op()(It, It) ... */ }:

template <class Iterator>
std::shared_ptr<Functor<Iterator>> createFunctor(std::string const& str)
{
  if (str == "Bar") return std::make_shared<FuncImpl_Bar<Iterator>>(/* args *);
  else return return std::make_shared<FuncImpl_Meow<Iterator>>(/* args *);
}

//...
auto MyFunctor = createFunctor<???>("Bar"); //what iterator type???

但是 AFAICS 你不需要知道createFoo 之外的函子的确切类型 - 如果createFoo 知道该类型就足够了:

Foo createFoo( ... // some parameters for foo objects
                                        std::string const& str ) //look mum, no templates!
{
  typedef whatever_the_container_i_use::iterator Iter;
  Functor<Iter> MyFunctor = createFunctor<Iter>(str);
  // calculate stuff for "foo" using functor "f"
}

//...
auto myFoo = createFoo(args, "Bar");
auto myOtherFoo = createFoo(args, "Moo");

简而言之:将工厂参数传递到您知道迭代器类型的位置,即您必须参数化仿函数工厂的类型。调用您知道需要每个输入的工厂,即类型和非类型参数。

【讨论】:

  • 谢谢,这是一个不错的解决方案。我现在正在考虑重写此设计,因为您的解决方案清楚地表明了我最初设计中的一些缺点。感谢您的意见:)
猜你喜欢
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 2019-06-05
  • 1970-01-01
  • 1970-01-01
  • 2018-03-29
  • 1970-01-01
  • 2017-04-23
相关资源
最近更新 更多