C++需要澄清代码

Question

我试图理解下面的代码所说的内容：

structcompare_pq;

struct compare_pq {
    bool operator() (Events *& a, Events *& b);
};

std::priority_queue<Events *, std::vector<Events *>, compare_pq> eventList;

我查看了priority_queue是什么以及它是如何声明的，但无法停止理解compare_pq在priority_queue eventList中做什么。另外，operator() 是做什么的，因为我之前从未见过 *& 和空运算符重载 operator()！

任何帮助将不胜感激。谢谢

Answer 1

operator() 是函数调用运算符。它允许您像使用函数一样使用类类型的对象，例如，

compare_pq my_comparator;
bool result = my_comparator(a, b);

重载operator() 的类类型的对象通常称为函数对象或函子。

std::priority_queue 的第三个模板参数用于比较函数。默认情况下，优先级队列使用 std::less 对其元素进行排序，这会将 operator< 应用于两个元素。您可以使用任何接受两个元素并返回一个布尔值的函数（或函数对象），指示第一个元素是否小于第二个元素。在这种情况下，“较小”是一个相对术语：优先级队列的 top() 是队列中当前“最大”的元素。

在这种情况下，您需要使用自定义比较函数，因为优先级队列存储指针，因此默认情况下它会按指针值对元素进行排序。自定义比较器（可能）取消引用指针并对指向的对象执行一些比较。

Events*& 只是对 Events 对象的指针的引用。它确实不需要通过引用传递。由于它只是一个指针，因此可以按值传递（例如，Events*）。如果您出于某种原因选择使用引用，那么它应该是 const 引用。

Answer 2

*&是对指针的引用。它的工作原理与任何其他类型的参考一样。在不太复杂的 C++ 代码中，您可能会看到使用双指针 (**)。

Compare_pq 是一个用于比较事件指针的函子。在这种情况下，每当需要比较时，priority_queue 可能会实例化一个compare_pq。

Event * a = new Event();
Event * b = a;
compare_pq foo;
bool result = foo(a, b);

运算符（）不为空。您正在查看一份声明。如果要实例化它，则必须在其他地方定义它。

Answer 3

我将尝试回答为什么使用函子的问题。当然，这只是一个猜测，因为我不是代码的作者，但我至少看到过几次关于它的讨论，而且共识似乎是，函子启用或至少使内联比较代码变得更容易。

函子是结构（或类），通常比常规函数更灵活，因为它们可以有一些成员，存储一些状态，可供operator()使用。在这种情况下，没有使用此优势，因此仿函数最有可能用于启用（或帮助）内联，或者只是因为作者习惯了这种常见模式。

为什么它有助于内联？让我们看一个简单的例子。让我们以 std::sort 为例，

template <class RandomAccessIterator, class Compare>
  void sort ( RandomAccessIterator first, RandomAccessIterator last, Compare comp );

假设您想要对 std::vector 进行排序，并且想要提供自定义比较器。

struct MyStructComp1
{
    bool operator()(int lhs, int rhs) const { /*...*/}
};

struct MyStructComp2
{
    bool operator()(int lhs, int rhs) const { /*...*/}
};

bool myFunctComp1 (int lhs, int rhs) const { /*...*/}
bool myFunctComp2 (int lhs, int rhs) const { /*...*/}

现在您可以通过以下方式使用 sort 模板

sort(myvector.begin(), myvector.end(), MyStructComp1()); // 1
sort(myvector.begin(), myvector.end(), MyStructComp2()); // 2
sort(myvector.begin(), myvector.end(), myFunctComp1);  // 3
sort(myvector.begin(), myvector.end(), myFunctComp2);  // 4

以下是编译器从模板创建的函数

sort<vector<int>::iterator, MyStrucComp1> // 1
sort<vector<int>::iterator, MyStrucComp2> // 2
sort<vector<int>::iterator, bool (*) (int lhs, int rhs)> // 3, // 4

由于排序模板中的 Compare 参数是类型，而函子是类型，因此编译器会创建不同的函数作为模板参数提供的每个函子的函数。 sort::iterator, MyStrucComp1> 和
sort::iterator, MyStrucComp2> 是两个不同的函数。因此，当创建 sort::iterator, MyStrucComp1> 时，就可以准确地知道比较代码是什么，并且可以简单地内联比较器。

然而，函数 myFunctComp1 和 myFunctComp2 的类型完全相同：
bool (*) (int lhs, int rhs) 并且编译器创建一个函数 sort::iterator, bool (*) (int lhs, int rhs)> 适用于 bool (*) (int lhs, int rhs) 类型的所有比较函数。我看到了意见，在这种情况下无论如何内联都是可能的，但我不知道如何做。

可以使用指向函数的指针作为模板参数创建模板，因为它是编译时常量，但它很丑陋，并且无法从函数参数中推导出常量。例如，如果 sort 定义为：

template <class RandomAccessIterator,
bool (*comparer) (typename RandomAccessIterator::value_type, typename RandomAccessIterator::value_type)>
    void sort ( RandomAccessIterator first, RandomAccessIterator last) {/*   */}

您必须像这样调用它

sort<std::vector<int>::iterator, myFunctComp1>(myvector.begin(), myvector.end());

您将为每个比较函数获得不同的排序，但函子要方便得多。