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

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::type 这样的模板类，因为 指向成员函数的指针可以有有趣的大小。

Answer 3

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

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

此外，可以比较指向成员的指针，或者指向
成员和一个空指针常量。指向成员转换的指​​针
执行（4.11）和资格转换（4.4）以将它们
到一个普通类型。如果一个操作数是空指针常量，则
公共类型是另一个操作数的类型。否则，常见的
type 是一个指向成员类型的指针，类似于 (4.4) 之一的类型
操作数，带有 cv 限定签名 (4.4)，即
操作数类型的 cv 限定签名的并集。 [笔记：
这意味着任何指向成员的指针都可以与空值进行比较
指针常量。 ] 如果两个操作数都为空，则它们比较相等。
否则，如果只有一个为空，则它们比较不相等。否则如果
要么是指向虚拟成员函数的指针，结果是
未指定。否则它们比较相等当且仅当它们
引用同一最派生对象 (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*);

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