无状态类仿函数什么时候可以代替 ac 风格的函数？

Question

我在 SO 上找到了一些很好的函子示例，例如这个，以及所有令人信服的例子似乎是在定义operator()的类中使用状态。

我在一本书中遇到了一个例子，它定义了没有状态的函数调用运算符，我不禁觉得这是一种尴尬的用法，并且普通风格的函数指针比使用运算符更好() 这里的各个方面 - 更少的代码，更少的变量（你必须实例化比较器），由于实例化，它可能更有效，并且不会丢失意义或封装（因为它只是一个函数）。

我知道 std::sort 允许您在 operator() 类和函数之间进行选择，但由于上述逻辑，我一直只使用函数。

某个班级可能受到青睐的原因是什么？

这是示例（已转述）：

class Point2D {
   //.. accessors, constructors
   int x,y;
};
class HorizComp {
public:
   bool operator()(const Point2D& p, const Point2D& q) const
   { return p.getX() < q.getX(); }
};

class VertComp {
public:
   bool operator()(const Point2D& p, const Point2D& q) const
   { return p.getY() < q.getY(); }
};

template <typename E, typename C>
void printSmaller(const E& p, const E& q, const C& isLess) {
   cout << (isLess(p, q) ? p : q) << endl; // print the smaller of p and q
}
//...
// usage in some function:
Point2D p(1.2, 3.2), q(1.5, 9.2);
HorizComp horizComp;
VertComp vorizComp;
printSmaller(p, q, horizComp);
printSmaller(p, q, vorizComp);

Answer 1

典型的原因是，当您执行此操作时：

bool less_than(const Point&, const Point&);
// ...
std::sort(..., &less_than);

谓词的模板参数如下：

bool(const Point&,const Point&)

由于排序函数接收函数指针，因此编译器更难以内联在 std::sort( ）。 函数

bool greater_than(const Point&, const Point&);

发生这种情况是因为您可能有另一个具有完全相同类型的 ，这意味着 std::sort() 实例将在两个谓词之间共享。 （请记住，我说过它会使内联变得更加困难，而不是不可能）。

相反，当您执行以下操作时：

struct less_than {
    bool operator()(const Point&, const Point&) const;
};
// ...
std::sort(..., less_than());


struct greater_than {
    bool operator()(const Point&, const Point&) const;
};
// ...
std::sort(..., greater_than());

编译器为每个谓词生成 std::sort() 的唯一模板实例化，从而更容易内联谓词的定义。

Answer 2

原因之一是运行时效率。如果将指针传递给函数，则编译器必须非常聪明才能为该函数内联生成代码。传递定义 operator() 的对象使编译器更容易生成内联代码。特别是对于排序之类的事情，这可以大大提高速度。

在 C++11 中，使用类的另一个原因是为了方便——您可以使用 lambda 表达式来定义类。

Answer 3

其他人对编译器内联函子的能力提出了很好的观点。函子对象与函数指针相比​​的另一个可能的优点是灵活性。函子可能是一个模板，可能是一个派生类，也许它具有运行时配置（即使在调用operator()时是无状态的等等。

Answer 4

另一个原因是有时一个比较功能是不够的。假设我们有一个指针向量：

struct X { string name; };
vector<shared_ptr<X>> v;

现在，如果我们想按名称对向量进行排序，我们必须为sort函数定义我们自己的谓词：

struct Cmp1
{
    bool operator()(const shared_ptr<X>& left, const shared_ptr<X>& right) const
    { return left->name < right->name; }
};

这很酷，但是当我们需要查找具有特定名称的对象时我们该怎么办？要使用 equal_range，谓词需要有两个不同的比较函数：

struct Cmp2
{
    bool operator()(const shared_ptr<X>& left, const string& right) const
    { return left->name < right; }

    bool operator()(const string& left, const shared_ptr<X>& right) const
    { return left < right->name; }
};

这允许我们使用 string 名称对象调用 equal_range：

equal_range(v.begin(), v.end(), name, Cmp2())

Answer 5

在模板库中，函子参数的状态在定义时未知，类类型的参数提供了比非实例函数指针更通用的接口。
STL 是一个很好的例子，其中有状态或无状态谓词和函子可以用作类和函数的参数。
如果模板编程不是计划的一部分，函数指针优于无状态函子类；函数的单个实例可以接受特定签名的所有函数指针，并且代码大小被最小化。但如果未来库扩展的可能性很小，函子会使它更加通用。