使用指向非静态成员函数的指针实现回调

假设我正在开发一个杂货清单管理器。我有一扇窗户，上面有GroceryListDisplay，这是一个显示购物清单上的商品的控件。杂货数据由程序的模型组件存储在GroceryStorage class.

要将保存的文件加载到我的程序中，必须使用从该文件导入的数据重新填充我的程序的模型组件。 View 组件需要收到此新数据的通知，否则 GUI 将不会更新并且用户无法看到导入的数据。

这是我为促进这一点而提出的概念。

/* A View class that represents a GUI control that displays the grocery list */
class GroceryListDisplay {
public:
  void repopulateFromModel(GroceryStorage* gs) {
    this->gs = gs;

    /* Delete every list entry that was loaded into GUI */
    this->clearList();

    /* Import grocery list from the Model */
    void (*itemAdder)(std::string) = addItemToList;
    this->gs->sendGroceryItemsToGUI(addItemToList);
  }

  void addItemToList(std::string);
  void clearList();
private:
  GroceryStorage* gs;
}

/* A Model class that stores the grocery list */
class GroceryStorage {
public:
  void sendGroceryItemsToGUI(void (*itemAdder)(std::string)) {
    /* Sends all stored items to the GUI */
    for (int i = 0; i < (int)this->groceryItems.size(); ++i)
      itemAdder(this->groceryItems[i]);
  }
private:
  std::vector<std::string> groceryItems;
}

当用户指示 GUI 导入某个文件时，视图将调用模型中的函数，从该给定文件加载数据。然后，repopulateFromModel调用函数以使 GUI 保持最新状态。

我正在经历使用函数指针进行回调的麻烦GroceryStorage::sendGroceryItemsToGUI因为否则模型必须知道它应该调用视图中的哪个函数，这将违反模型/视图原则。

这段代码有一个大问题。如果我在现实生活中使用这个概念，我会收到一个编译器错误，内容类似于

错误：“void (GroceryListDisplay::)(std::string)”类型的参数与“void (*)(std::string)”不匹配

编译器是否要求我对函数指针所源自的类的名称进行硬编码？我不能这样做，因为这意味着模型知道哪个视图类负责处理回调，这又将是模型/视图违规。

我是否误解了函数指针的工作原理？

最好的办法是抽象化，不再使用原始函数指针。通常有两种方法：

第一个是使用std::bind + std::function（或他们的boost::旧编译器上的对应项缺乏std:: or std::tr1::实现）：

#include <functional>
#include <vector>
#include <string>

class GroceryStorage {
public:
    void sendGroceryItemsToGUI(std::function<void(std::string const&)> const& itemAdder) {
        for (groceryItems_t::const_iterator iter = groceryItems.begin(), iter_end = groceryItems.end(); iter != iter_end; ++iter)
            itemAdder(*iter);
    }

private:
    typedef std::vector<std::string> groceryItems_t;
    groceryItems_t groceryItems;
};

class GroceryListDisplay {
public:
    void repopulateFromModel(GroceryStorage* const gs_) {
        gs = gs_;
        clearList();
        gs_->sendGroceryItemsToGUI(std::bind(&GroceryListDisplay::addItemToList, this, std::placeholders::_1));
    }

    void addItemToList(std::string const&);
    void clearList();

private:
    GroceryStorage* gs;
};

（请注意，我已经改变了addItemToList采取std::string by const&因为通过一个std::stringby value 在 99% 的情况下都是愚蠢的，但这并不是严格必要的步骤。）

第二个是要使sendGroceryItemsToGUI一个函数模板而不是采用std::function:

#include <functional>
#include <vector>
#include <string>

class GroceryStorage {
public:
    template<typename F>
    void sendGroceryItemsToGUI(F const& itemAdder) {
        for (groceryItems_t::const_iterator iter = groceryItems.begin(), iter_end = groceryItems.end(); iter != iter_end; ++iter)
            itemAdder(*iter);
    }

private:
    typedef std::vector<std::string> groceryItems_t;
    groceryItems_t groceryItems;
};

class GroceryListDisplay {
public:
    void repopulateFromModel(GroceryStorage* const gs_) {
        gs = gs_;
        clearList();
        gs_->sendGroceryItemsToGUI(std::bind(&GroceryListDisplay::addItemToList, this, std::placeholders::_1));
    }

    void addItemToList(std::string const&);
    void clearList();

private:
    GroceryStorage* gs;
};

后一种方法将always更有效，但有时不切实际/不合需要，因为函数模板必须始终在头文件中定义。