成员函数指针的实际用途是什么？

Question

我已经通读了这篇文章，我从中得到的是当您想调用指向成员函数的指针时，您需要一个实例（指向一个的指针或堆栈引用）并这样调用它：

(instance.*mem_func_ptr)(..)
or
(instance->*mem_func_ptr)(..)

我的问题基于此：因为您有实例，为什么不直接调用成员函数，如下所示：

instance.mem_func(..) //or: instance->mem_func(..)

指向成员函数的指针的合理/实际用途是什么？

[编辑]

我正在玩 X-development &达到了我正在实现小部件的阶段；用于将 X 事件转换为我的类的事件循环线程当事件到达时，小部件需要为每个小部件/窗口启动线程；为了正确地做到这一点，我认为我需要指向类中事件处理程序的函数指针。

事实并非如此：我确实发现我可以以更清晰和更清晰的方式做同样的事情。通过简单地使用虚拟基类来更简洁的方式。不需要任何指向成员函数的指针。正是在开发上述内容时，出现了对成员函数指针的实际可用性/含义的怀疑。

您需要对实例的引用才能使用成员函数指针，这一简单事实就不再需要引用了。

[编辑-@sbi &其他]

这是一个示例程序来说明我的观点： （特别注意“Handle_THREE()”）

#include <iostream>
#include <string>
#include <map>


//-----------------------------------------------------------------------------
class Base
{
public:
    ~Base() {}
    virtual void Handler(std::string sItem) = 0;
};

//-----------------------------------------------------------------------------
typedef void (Base::*memfunc)(std::string);

//-----------------------------------------------------------------------------
class Paper : public Base
{
public:
    Paper() {}
    ~Paper() {}
    virtual void Handler(std::string sItem) { std::cout << "Handling paper\n"; }
};

//-----------------------------------------------------------------------------
class Wood : public Base
{
public:
    Wood() {}
    ~Wood() {}
    virtual void Handler(std::string sItem) { std::cout << "Handling wood\n"; }
};


//-----------------------------------------------------------------------------
class Glass : public Base
{
public:
    Glass() {}
    ~Glass() {}
    virtual void Handler(std::string sItem) { std::cout << "Handling glass\n"; }
};

//-----------------------------------------------------------------------------
std::map< std::string, memfunc > handlers;
void AddHandler(std::string sItem, memfunc f) { handlers[sItem] = f; }

//-----------------------------------------------------------------------------
std::map< Base*, memfunc > available_ONE;
void AddAvailable_ONE(Base *p, memfunc f) { available_ONE[p] = f; }

//-----------------------------------------------------------------------------
std::map< std::string, Base* > available_TWO;
void AddAvailable_TWO(std::string sItem, Base *p) { available_TWO[sItem] = p; }

//-----------------------------------------------------------------------------
void Handle_ONE(std::string sItem)
{
    memfunc f = handlers[sItem];
    if (f)
    {
        std::map< Base*, memfunc >::iterator it;
        Base *inst = NULL;
        for (it=available_ONE.begin(); ((it != available_ONE.end()) && (inst==NULL)); it++)
        {
            if (it->second == f) inst = it->first;
        }
        if (inst) (inst->*f)(sItem);
        else std::cout << "No instance of handler for: " << sItem << "\n";
    }
    else std::cout << "No handler for: " << sItem << "\n";
}

//-----------------------------------------------------------------------------
void Handle_TWO(std::string sItem)
{
    memfunc f = handlers[sItem];
    if (f)
    {
        Base *inst = available_TWO[sItem];
        if (inst) (inst->*f)(sItem);
        else std::cout << "No instance of handler for: " << sItem << "\n";
    }
    else std::cout << "No handler for: " << sItem << "\n";
}

//-----------------------------------------------------------------------------
void Handle_THREE(std::string sItem)
{
    Base *inst = available_TWO[sItem];
    if (inst) inst->Handler(sItem);
    else std::cout << "No handler for: " << sItem << "\n";
}


//-----------------------------------------------------------------------------
int main()
{
    Paper p;
    Wood w;
    Glass g;


    AddHandler("Paper", (memfunc)(&Paper::Handler));
    AddHandler("Wood", (memfunc)(&Wood::Handler));
    AddHandler("Glass", (memfunc)(&Glass::Handler));

    AddAvailable_ONE(&p, (memfunc)(&Paper::Handler));
    AddAvailable_ONE(&g, (memfunc)(&Glass::Handler));

    AddAvailable_TWO("Paper", &p);
    AddAvailable_TWO("Glass", &g);

    std::cout << "\nONE: (bug due to member-function address being relative to instance address)\n";
    Handle_ONE("Paper");
    Handle_ONE("Wood");
    Handle_ONE("Glass");
    Handle_ONE("Iron");

    std::cout << "\nTWO:\n";
    Handle_TWO("Paper");
    Handle_TWO("Wood");
    Handle_TWO("Glass");
    Handle_TWO("Iron");

    std::cout << "\nTHREE:\n";
    Handle_THREE("Paper");
    Handle_THREE("Wood");
    Handle_THREE("Glass");
    Handle_THREE("Iron");
}

---

{编辑] 上面示例中直接调用的潜在问题：
在 Handler_THREE() 中，方法的名称必须是硬编码的，强制在使用它的任何地方进行更改，以将任何更改应用于该方法。使用指向成员函数的指针，唯一需要进行的额外更改是创建指针的位置。

[编辑]从答案中收集的实际用途：

来自Chubsdad 的回答 :
内容：使用专用的“调用者”函数来调用 mem-func-ptr；
好处：使用其他对象提供的函数来保护代码
如何：如果特定函数是在很多地方使用并且名称和/或参数发生变化，那么您只需更改分配为指针的名称，并调整“Caller”函数中的调用。 （如果该函数用作 instance.function() ，则必须在各处进行更改。）

来自 Matthew Flaschen 的回答：
内容：类中的局部特化
好处：使代码更清晰、更简单、更易于使用和维护
如何：用（可能）大型 switch()/if 替换传统上使用复杂逻辑实现的代码-then 带有直接指向专业化指针的语句；与上面的“Caller”功能非常相似。

Answer 1

与使用任何函数指针的原因相同：您可以在调用之前使用任意程序逻辑来设置函数指针变量。您可以使用开关、if/else，将其传递到函数中，等等。

编辑：

问题中的示例确实表明您有时可以使用虚函数作为指向成员函数的指针的替代方法。这并不奇怪，因为编程通常有多种方法。

这是一个虚拟函数可能没有意义的例子。就像OP中的代码一样，这只是为了说明，而不是特别现实。它显示了一个具有公共测试功能的类。它们使用内部的、私有的函数。内部函数只能在setup之后调用，并且必须在之后调用teardown。

#include <iostream>

class MemberDemo;
typedef void (MemberDemo::*MemberDemoPtr)();

class MemberDemo
{
    public:
    void test1();
    void test2();

    private:
    void test1_internal();
    void test2_internal();
    void do_with_setup_teardown(MemberDemoPtr p);
};

void MemberDemo::test1()
{
    do_with_setup_teardown(&MemberDemo::test1_internal);
}

void MemberDemo::test2()
{
    do_with_setup_teardown(&MemberDemo::test2_internal);
}

void MemberDemo::test1_internal()
{
    std::cout << "Test1" << std::endl;
}

void MemberDemo::test2_internal()
{
    std::cout << "Test2" << std::endl;
}

void MemberDemo::do_with_setup_teardown(MemberDemoPtr mem_ptr)
{
    std::cout << "Setup" << std::endl;
    (this->*mem_ptr)();
    std::cout << "Teardown" << std::endl;
}

int main()
{
    MemberDemo m;
    m.test1();
    m.test2();
}

Answer 2

我的问题是基于此：既然有了实例，为什么不直接调用成员函数[？]

前面：在超过 15 年的 C++ 编程中，我可能使用过成员指针两次或三次。有了虚拟函数，它就没有多大用处了。

如果您想调用一个对象（或多个对象）上的某些成员函数，并且您必须先决定调用哪个成员函数，然后才能找到要调用的对象，则可以使用它们。 这里是有人想要这样做的一个例子。

Answer 3

我发现，当您查看诸如 boost::bind() 等更高级别的构造时，成员函数指针的真正用处就体现出来了。这将允许您将函数调用包装为一个对象，该对象可以稍后绑定到特定的对象实例，然后作为可复制对象传递。这是一个非常强大的习惯用法，允许延迟回调、委托和复杂的谓词操作。请参阅我之前的文章了解一些示例：

https://stackoverflow。 com/questions/1596139/hidden-features-and-dark-corners-of-stl/1596626#1596626

Answer 4

成员函数与许多函数指针一样，充当回调。您可以通过创建一些调用您的方法的抽象类来管理没有它们的情况，但这可能需要大量额外的工作。

一种常见的用途是算法。在 std::for_each 中，我们可能想要调用集合中每个成员的类的成员函数。我们还可能想对集合的每个成员调用我们自己类的成员函数 - 后者需要 boost::bind 来实现，前者可以使用 STL mem_fun 系列类来完成（如果我们没有shared_ptr 的集合，在这种情况下我们也需要 boost::bind ）。我们还可以在某些查找或排序算法中使用成员函数作为谓词。 （这消除了我们编写一个自定义类来重载operator()来调用我们类的成员的需要，我们只需将它直接传递给boost::bind）。

正如我提到的，另一个用途是回调，通常在事件驱动的代码中。当操作完成时，我们希望调用类的方法来处理完成。这通常可以包装到 boost::bind 函子中。在这种情况下，我们必须非常小心地正确管理这些对象的生命周期及其线程安全性（特别是如果出现问题，调试起来会非常困难）。尽管如此，它再次可以让我们免于编写大量的“包装”代码。

Answer 5

有很多实际用途。我想到的一个如下：

假设有一个如下所示的核心函数（适当定义了 myfoo 和 MFN），

void dosomething(myfoo &m, MFN f){   // m could also be passed by reference to 
                                     // const
   m.*f();
}

这样的函数在存在指向成员函数的指针时，对扩展开放，对修改关闭（OCP）

另请参阅 安全布尔习惯用法，巧妙地使用指向成员的指针。

Answer 6

成员函数指针的最佳用途是打破依赖关系。

需要指向成员函数的指针的一个很好的例子是订阅者/发布者模式：

http://en.wikipedia。 org/wiki/发布/订阅

Answer 7

在我看来，成员函数指针的原始形式对于普通程序员来说并不是很有用。 OTOH，像 ::std::tr1::function 这样的构造将成员函数指针与指向它们应该操作的对象的指针包装在一起，非常有用。

当然 ::std::tr1::function 非常复杂。因此，我将给您一个简单的示例，如果您有 ::std::tr1::function 可用，您实际上不会在实践中使用该示例：

// Button.hpp
#include <memory>

class Button {
 public:
   Button(/* stuff */) : hdlr_(0), myhandler_(false) { }
   ~Button() {
      // stuff
      if (myhandler_) {
         delete hdlr_;
      }
   }
   class PressedHandler {
    public:
      virtual ~PressedHandler() = 0;

      virtual void buttonPushed(Button *button) = 0;
   };

   // ... lots of stuff

   // This stores a pointer to the handler, but will not manage the
   // storage.  You are responsible for making sure the handler stays
   // around as long as the Button object.
   void setHandler(const PressedHandler &hdlr) {
      hdlr_ = &hdlr;
      myhandler_ = false;
   }

   // This stores a pointer to an object that Button does not manage.  You
   // are responsible for making sure this object stays around until Button
   // goes away.
   template <class T>
   inline void setHandlerFunc(T &dest, void (T::*pushed)(Button *));

 private:
   const PressedHandler *hdlr_;
   bool myhandler_;

   template <class T>
   class PressedHandlerT : public Button::PressedHandler {
    public:
      typedef void (T::*hdlrfuncptr_t)(Button *);

      PressedHandlerT(T *ob, hdlrfuncptr_t hdlr) : ob_(ob), func_(hdlr) { }
      virtual ~PressedHandlerT() {}

      virtual void buttonPushed(Button *button) { (ob_->*func_)(button); }

    private:
      T * const ob_;
      const hdlrfuncptr_t func_;
   };
};

template <class T>
inline void Button::setHandlerFunc(T &dest, void (T::*pushed)(Button *))
{
   PressedHandler *newhandler = new PressedHandlerT<T>(&dest, pushed);
   if (myhandler_) {
      delete hdlr_;
   }
   hdlr_ = newhandler;
   myhandler_ = true;
}

---

// UseButton.cpp
#include "Button.hpp"
#include <memory>

class NoiseMaker {
 public:
   NoiseMaker();
   void squee(Button *b);
   void hiss(Button *b);
   void boo(Button *b);

 private:
   typedef ::std::auto_ptr<Button> buttonptr_t;
   const buttonptr_t squeebutton_, hissbutton_, boobutton_;
};


NoiseMaker::NoiseMaker()
     : squeebutton_(new Button), hissbutton_(new Button), boobutton_(new Button)
{
   squeebutton_->setHandlerFunc(*this, &NoiseMaker::squee);
   hissbutton_->setHandlerFunc(*this, &NoiseMaker::hiss);
   boobutton_->setHandlerFunc(*this, &NoiseMaker::boo);
}

假设 Button 位于库并且您无法更改，我很高兴看到您使用虚拟基类干净地实现该库，而无需在某处诉诸 switch 或 if else if 构造。

Answer 8

指向成员函数类型的指针的全部要点是它们充当引用特定方法的运行时方式。当您使用“常用”语法进行方法访问时，

object.method();
pointer->method();

method 部分是您要调用的方法的固定编译时规范。它被硬编码到您的程序中。它永远不会改变。但是，通过使用指向成员函数类型的指针，您可以用在方法的运行时规范中可更改的变量替换该固定部分。

为了更好地说明这一点，让我做以下简单的类比。假设您有一个数组，

int a[100];

您可以使用固定的编译时索引访问其元素，

a[5]; a[8]; a[23];

在这种情况下，特定索引被硬编码到您的程序中。但是您也可以使用运行时索引访问数组的元素 - 一个整数变量i，

a[i];

i的值不是固定的，它可以在运行时改变，从而允许您可以在运行时选择数组的不同元素。这与指向成员函数类型的指针的功能非常相似。

您提出的问题（“既然您有实例，为什么不直接调用成员函数”）可以转换为这个数组上下文。您基本上是在问：“当我们有像 a[1] 和 这样的直接编译时常量访问时，为什么我们需要变量索引访问 a[i] >a[3]？”我希望您知道这个问题的答案并认识到特定数组元素的运行时选择的价值。

这同样适用于指向成员函数类型的指针：它们再次允许您执行特定类方法的运行时选择。

Answer 9

用例是您有多个具有相同签名的成员方法，并且您想要构建在给定情况下应该调用哪个成员方法的逻辑。这有助于实现状态机算法。

不是日常用的东西...

Answer 10

想象一下，您有一个函数可以根据传递的参数调用多个不同函数之一。

您可以使用巨大的 if/else if 语句
您可以使用 switch 语句
或者您可以使用函数指针表（跳转表）

如果您有很多不同的选项，则跳转表可以是一种更简洁的方式来安排代码......

但这取决于个人喜好。无论如何，Switch 语句和跳转表对应于或多或少相同的编译代码:)

Answer 11

成员指针+模板=纯粹的胜利。

例如 如何判断类在编译时是否包含某个成员函数

或

template<typename TContainer,
         typename TProperty,
         typename TElement = decltype(*Container().begin())>
TProperty grand_total(TContainer& items, TProperty (TElement::*property)() const)
{
   TProperty accum = 0;
   for( auto it = items.begin(), end = items.end(); it != end; ++it) {
       accum += (it->*property)();
   }
   return accum;
}

auto ship_count = grand_total(invoice->lineItems, &LineItem::get_quantity);
auto sub_total = grand_total(invoice->lineItems, &LineItem::get_extended_total);
auto sales_tax = grand_total(invoice->lineItems, &LineItem::calculate_tax);

Answer 12

要调用它，您需要一个对实例的引用，但随后您可以调用 func direct &不需要指向它的指针。

这完全没有抓住重点。这里有两个独立的问题：

• 在稍后的某个时间点采取什么操作，
• 对什么对象执行该操作

拥有对实例的引用满足第二个要求。指向成员函数的指针解决了第一个问题：它们是一种非常直接的方式来记录（在程序执行的某个时刻）应在执行的稍后阶段（可能由程序的另一部分）采取哪些操作。

示例

假设您有一只猴子，它可以亲吻人类或挠痒痒。下午 6 点，您的程序应该将猴子放开，并知道猴子应该访问谁，但下午 3 点左右，您的用户将输入应采取的操作。

初学者的方法

因此，下午 3 点你可以设置一个变量“enum Action { Kiss, Tickle } action;”，然后下午 6 点你可以执行类似“if (action == Kiss) Monkey->kiss(person); else”的操作猴子->挠痒痒（人）”。

问题

但是引入了额外的编码级别（引入了 Action 类型来支持这一点 - 可以使用内置类型，但更容易出错并且本质上意义较小）。然后 - 在确定下午 3 点应该采取什么操作后，下午 6 点，您必须冗余地查阅该编码值来决定采取哪个操作，这将需要另一个 if/else 或切换编码值。这一切都很笨拙、冗长、缓慢且容易出错。

成员函数指针

更好的方法是使用更专门的变量 - 成员函数指针 - 它直接记录下午 6 点要执行的操作。这就是成员函数指针。这是一个之前设置的亲吻或挠痒选择器，为猴子创建一个“状态” - 是挠痒痒的还是亲吻的 - 可以稍后使用。后面的代码只是调用已设置的任何函数，而无需考虑可能性或具有任何 if/else-if 或 switch 语句。

要调用它，您需要一个对实例的引用，但随后您可以调用 func direct &不需要指向它的指针。

回到这一点。因此，如果您在编译时决定要采取哪些操作（即程序中的 X 点，这肯定会很棘手），那么这很好。当您不确定并且想要将操作的设置与这些操作的调用分离时，可以使用函数指针。