成员函数可以通过哪些方式相互比较？

Question

我想知道是否可以将 2 个成员函数与“void*，但这也不起作用。

template <class Receiver, class Sender>
class CallBack2 : public ICallBack2 {

protected:

    Receiver* receiver;
    void(Receiver::*function)(Sender*);
    Sender* sender;

public:

    CallBack2(Receiver* _receiver, void(Receiver::*_function)(Sender*), Sender* _sender) : receiver(_receiver), function(_function), sender(_sender) {};
    virtual ~CallBack2() {};

    virtual void callBack() {
        (receiver->*function)(sender);
    }

    virtual bool operator<(const ICallBack2* _other) const {
        CallBack2<Receiver, Sender>* other = (CallBack2<Receiver, Sender>*)_other;
        if (receiver < other->receiver) {
            return true;
        } else if (receiver == other->receiver && function < other->function) {
            return true; // this line gives the error
        }
        return false;
    }
};

有什么想法吗？

Answer 1

C++03 § 5.9，涵盖了内置 、= 的语义，没有提到指向成员和状态的指针：

未指定其他指针比较。

根据§ 8.3.3，3

“指向成员的指针”类型不同于“指针”类型，

因此，我们可以得出结论，将关系运算符应用于指向成员（无论是函数还是字段）的指针的结果是未指定的。

请注意，“未指定行为”与“未定义行为”不同，但仍然意味着您无法有效地应用运算符，因为不同的实现可能会产生不同的结果。 “未指定”基本上意味着实现可以定义行为。

Answer 2

如果您只是想任意命令它们成为集合/映射中的键，那么您可以reinterpret_cast 它们。您可能需要像 exact_int<sizeof(void (Foo::*bar)())>::type 这样的模板类，因为 pointers to member functions can have funny sizes。

Answer 3

5.9.7（关系运算符）：“未指定其他指针比较”。

由于 5.9 不清楚（它处理函数，但不明确处理成员函数），快速浏览 5.10（相等比较）清楚地将 函数 与 成员函数 区分开来：

另外，可以比较指向成员的指针，或者指向 成员和一个空指针常量。指向成员转换的指​​针 （4.11）和资格转换（4.4）被执行以带来他们 为普通类型。如果一个操作数是空指针常量，则 普通类型是另一个操作数的类型。否则，常见的 type 是指向成员类型的指针，类似于 (4.4) 的类型之一 具有 cv 限定签名 (4.4) 的操作数，即 操作数类型的 cv 限定签名的联合。 [笔记： 这意味着任何指向成员的指针都可以与 null 进行比较 指针常量。 ] 如果两个操作数都为空，它们比较相等。 否则，如果只有一个为空，则它们比较不相等。否则如果 要么是指向虚成员函数的指针，结果是 未指定。否则它们比较相等当且仅当它们会 引用同一个最衍生对象（1.8）的同一个成员或 如果它们被一个假设的对象取消引用，则相同的子对象 关联的类类型。

所以你可以使用运算符，==和!=的含义是指定的，但<、>、<=和>=的含义是未指定的。

特别是，没有任何东西强制传递性，所以不清楚将它们放在一个集合中是否可以。

Answer 4

虽然描述有点冗长，但有一个假人怎么样 变量并比较它的指针如下？

template< class T >
struct comparable_value {
    T value;
    char *id;

    comparable_value( T value, char* id ) : value( value ), id( id ) {}

    bool operator<( comparable_value const& x ) const {
        return std::less< char* >()( id, x.id );
    }
};

template< class T, T V >
comparable_value< T > get_comparable_value() {
    static char dummy;
    return comparable_value< T >( V, &dummy );
}

struct A {
    void f() { puts( "f" ); }
    void g() { puts( "g" ); }
};

int main() {
    typedef void (A::*MF)();
    typedef std::set< comparable_value< MF > > set_t;
    set_t s;
    s.insert( get_comparable_value< MF, &A::f >() );
    s.insert( get_comparable_value< MF, &A::g >() );
    A a;
    for ( set_t::iterator i = s.begin(), e = s.end();  i != e;  ++ i )
        (a.*i->value)();
}

这是对ideone 的测试。

Answer 5

您可以执行 Ise 的想法，只需将其包含在 Callback2 类中，这样您就无需更改使用该类的任何内容。

template <class Receiver, class Sender>class CallBack2 : public ICallBack2 {
private:
   static int nextSequenceNumber;
   int sequenceNumber;

//snip

public:
  CallBack2(Receiver* _receiver, void(Receiver::*_function)(Sender*), Sender* _sender) :
   sequenceNumber(nextSequenceNumber++), receiver(_receiver), function(_function), sender(_sender) {};

//snip

virtual bool operator<(const ICallBack2* _other) const {
  return sequenceNumber<_other->sequenceNumber;}

Answer 6

获取成员函数的地址会导致无法存储在变量中的常量表达式。它只能用于与另一个表达式比较是否相等，该表达式表示一个函数的地址，该函数采用相同的参数集，具有相同的返回类型和相同的 this 指针类型。

    class a 
    {
    public:
        virtual void test();
    };
    class b
    {
    public:
        virtual void test();
    };

    ....
    a *pa = new a;
    b *pb = new b;

    if (pb->test == pa->test) // legal, but  false
    if (pb->test==pb::test) // legal and true
    // pa->test will evaluate to a::test, although calling pa->test() would call
    // b::test()

Answer 7

比较两个函数指针是没有意义的。您可以比较的实际上是这些函数的返回值：

*function(sender) < *(other->function)(sender)

但在您的情况下，您将函数声明为：

void(Receiver::*function)(Sender*);

所以，在我看来。比较功能是没有用的。要么更改函数的签名以返回某些内容，要么更好地描述您的业务场景，以便我们更好地了解您想要什么。