Yebangyu's Blog

Fond of Concurrency Programming and Machine Learning

C++函数对象(function object)的应用

假如我们实现了这样的一个单向链表:

1
2
3
4
5
6
7
8
9
10
11
12
13
class LinkedListNode
{
  int data_;
  LinkedListNode *next_;
};
class LinkedList
{
  public:
    void insert(LinkedListNode* &p);
    void del(LinkedListNode *p);
  private:
    LinkedListNode *head_;
};

其中insert将p插入到head_为头指针的链表中,而p对应的内存由外面分配好,调用的时候类似于这样:

1
2
3
LinkedList list;
LinkedListNode *p = new LinkedListNode(2, NULL);
list.insert(p);

其中,p可能是通过new得到,也可能是malloc出来。好,问题来了:

这个类的del函数应该如何实现呢?如果节点是new出来的,我们得delete;如果是malloc出来的,我们得使用配套的free。否则,行为就是undefined。而且,用户还可能实现了自己的定制的内存分配回收例程。

我们并不知道该内存是如何分配得到的。这就是问题所在。

解决方法是让用户将正确的、对应的、适配的资源释放例程传递进来,然而delete是expression,free是函数,更悲剧的是不同用户实现的资源回收函数原型不尽相同。如何做呢?

函数对象是解决这个问题的利器。我们可以这样:

1
2
3
4
5
6
7
8
9
template<typename CallBack>
class LinkedList
{
  public:
    void insert(LinkedListNode* &p);
    void del(LinkedListNode *p);
  private:
    LinkedListNode *head_;
};

在del中:

1
2
3
4
5
6
7
8
void del(LinkedListNode *p)
{
  //...
  LinkedListNode *prev = get_prev(p);
  prev->next_ = p->next_;
  CallBack cb;
  cb(p);//调用用户提供的资源回收例程
}

用户需要实现自己的CallBack类的operator()成员函数。如下所示:

1
2
3
4
5
6
7
8
class MyReclaimRoutine
{
  public:
    void operator() (LinkedListNode *p)
    {
      delete p; //free(p) ? my_release_func(p) ? all up to you!
    }
};

然后就万事大吉了:

1
2
3
4
LinkedList<MyReclaimRoutine> list;
LinkedListNode *p = new LinkedListNode(2, NULL);
list.insert(p);
list.del(p);//ok! delete p will be called