C++ 函数对象和函数指针之间的区别？

我定义了一个类，然后将指向Foo的指针保存在priority_队列中，并使用我定义的cmp函数

但如果cmp函数调用函数对象，则会发生错误：

class Foo
{
    friend bool cmp(Foo *, Foo *);
public:
    Foo() = default;
    Foo(int x):val(x) {}
private:
    int val;
};
bool cmp(Foo *a, Foo *b)
{
    return a->val < b->val;
}
int main()
{
    priority_queue<Foo*, vector<Foo*>, decltype(cmp)*> que;
    que.push(new Foo(5));
    que.push(new Foo(6));
    return 0;
}

class-Foo
{
友人布尔cmp（Foo*，Foo*）；
公众：
Foo（）=默认值；
Foo（intx）：val（x）{}
私人：
int-val；
};
bool cmp（Foo*a，Foo*b）
{
返回a->valval；
}
int main（）
{
优先权；
(五);；
(新富(6));；
返回0；
}

functione对象正常运行

class Foo
{
    friend struct cmp;
public:
    Foo() = default;
    Foo(int x):val(x) {}
private:
    int val;
};
struct cmp
{
    bool operator()(Foo *a, Foo *b)
    {
        return a->val < b->val;
    }
};
int main()
{
    priority_queue<Foo*, vector<Foo*>, cmp> que;
    que.push(new Foo(5));
    que.push(new Foo(6));
    return 0;
}

class-Foo
{
友元结构；
公众：
Foo（）=默认值；
Foo（intx）：val（x）{}
私人：
int-val；
};
结构cmp
{
布尔运算符（）（Foo*a，Foo*b）
{
返回a->valval；
}
};
int main（）
{
优先权；
(五);；
(新富(6));；
返回0；
}

您需要使用希望用作比较的函数构造

que

变量

#include <vector>
#include <queue>

using namespace std;

class Foo
{
    friend bool cmp(Foo*, Foo*);
public:
    Foo() = default;
    Foo(int x):val(x) {}
private:
    int val;
};
bool cmp(Foo* a, Foo* b)
{
    return a->val < b->val;
}
int main()
{
    //                                                     vvv
    priority_queue<Foo*, vector<Foo*>, decltype(cmp)*> que(cmp);
    que.push(new Foo(5));
    que.push(new Foo(6));

    return 0;
}

#包括
#包括
使用名称空间std；
福班
{
友人布尔cmp（Foo*，Foo*）；
公众：
Foo（）=默认值；
Foo（intx）：val（x）{}
私人：
int-val；
};
bool cmp（Foo*a，Foo*b）
{
返回a->valval；
}
int main（）
{
//vvv
优先级队列（cmp）；
(五);；
(新富(6));；
返回0；
}

IDE是代码：：阻止“发生错误”？真的吗？不编译错误函数的默认初始化指针的值为

nullptr

。

struct cmp

的默认初始化实例是有效实例

decltype（cmp）

只是

bool（Foo*a，Foo*b）

-“一些函数取两个

Foo*

并返回一个

bool

”。没有任何东西将此连接到名为

cmp

的特定函数。类似地，

decltype（42）x

相当于

intx-它不会神奇地给出
x
值
42
。