c++ - 关于成员函数指针的使用(和有用性)与直接调用成员函数

Question

我不熟悉指向成员函数的指针，我想知道它们的优缺点。

具体来说，考虑一下:

#include <iostream>
#include <list>

using namespace std;

class VariableContainer;

class Variable
{
public:
  Variable (int v) : value (v), cb_pointer (0) {}
  ~Variable () {}

  void SetCallback (void (VariableContainer::*cb)(int)) {
    cb_pointer = cb;
  }
  void FireCallback (void) {
    /* I need a reference to a VariableContainer object! */
  }

private:
  int value;
  void (VariableContainer::*cb_pointer) (int);
};

class VariableContainer
{
public:
  VariableContainer () {}
  ~VariableContainer () {}

  void AddVar (Variable &v) {
    v.SetCallback (&VariableContainer::Callback);
  }
  void Callback (int v) { cout << v << endl; }
};

int main ()
{
  Variable v (1);
  VariableContainer vc;

  vc.AddVar (v);
  v.FireCallback();

  return 0;
}

如评论中所述，要触发回调 ( FireCallback )，我需要一些对现有 VariableContainer 的引用对象，应作为 VariableContainer::AddVar (...) 的附加参数提供.现在:

1. 我应该使用指向成员函数的指针吗？还是直接调用Callback (...) (因为我有一个指向 VariableContainer 对象的指针)？
2. 每种解决方案的优缺点是什么？

TIA,吉尔

Answer 1

根据 future 的变化，您可以决定:

• 其他函数将由变量的 FireCallback 调用 => 指向 mf 的指针可能有用，但其他机制更像 c++
• 只会调用“回调”函数 => 坚持直接调用 arg->CallBack()。

该问题的一个可能解决方案是使用接口(interface)层:这不过是观察者模式的一种实现。这有点面向对象，因此冗长，但语法更简单。

class Observer {
public:
    virtual ~Observer(){};
    virtual void callback( int v ) = 0;
};

// actual implementation
class MyCallbackObserver : public Observer {
    virtual void callback( int v ) { std::cout << v << std::endl; }
    void some_other_method( int v ) { std::cout << "other " << v ; }
};

你的 Variable 类会有一个装满观察者的容器:

class Variable {
public:
   std::vector<Observer*> observers; // warning: encapsulation omitted
   void FireCallback(){
      // assuming C++ 0x
      for( auto it : observers ) {
        (*it)->Callback( value );
      }
   }

如果需要在同一个对象上调用其他函数，你可以引入一个包装器:

class OtherCaller: public Observer {
 public:
     MyObserver* obs;
     virtual void callback( int v ) { obs->some_other_method( v ); }
}

并将其添加到集合中:

Variable var;
MyObserver m;
OtherCaller mo;
mo.obs = &m;

var.observers.push_back(&m);
var.observers.push_back(&mo);

var.FireCallback();