系统程序员成长计划容器与算法(二)（下）

系统程序员成长计划-容器与算法(二)（下）

转载时请注明出处和作者联系方式
文章出处：http://www.limodev.cn/blog
作者联系方式：李先静 <xianjimli at hotmail dot com>

这个反序函数的原理很简单，有的读者很快就写出来了：

Ret invert(LinearContainer* linear_container)
{
    int i = 0;
    int j = 0;
    void* data1 = NULL;
    void* data2 = NULL; 

    return_val_if_fail(linear_container != NULL, RET_INVALID_PARAMS); 

    j = linear_container_length(linear_container) - 1;
    for(; i < j; i++, j--)
    {
        linear_container_get_by_index(linear_container, i, &data1);
        linear_container_get_by_index(linear_container, j, &data2);
        linear_container_set_by_index(linear_container, i, data2);
        linear_container_set_by_index(linear_container, j, data1);
    } 

    return RET_OK;
}

这种实现利用我们抽象的 LinearContainer接口，它同时适用于双向链表和动态数组，可惜无法满足第三个条件，双向链表和动态数组的性能差异很大。原因是，动态数组通 过偏移量可以定位，而双向链表则需要一个一个的移动指针才能定位，在循环内部调用get_by_index/ set_by_index更加剧它们在性能上的差异。

有的读者可能尝试了用foreach去实现，foreach确实很好用，但它的缺点是只能按固定的顺序去遍历元素，不能同时即反序又顺序的遍历，所 以用foreach实现上述算法是有点困难的。这里我们引入一个新的概念：迭代器。迭代器是一种更灵活的遍历行为的抽象，它可以按任意顺序去访问容器内的 元素，而又不暴露容器的内部结构。

在引入迭代器之前，我们分析一下invert的算法，先考虑针对双向链表的实现：

1. 定义两个指针，一个指向链表的首结点，一个指向链表的尾结点。
2. 交换两个指针指向的内容。
3. 前面的指针向后移，后面的指针向前移，重复第二步直到两个指针相遇。

仔细看看上面的算法，我们发现在整个过程中，操作的只是两个指针。关于这个指针，它具有下列行为：

o 获取指针指向的数据。
o 设置指针指向的数据。
o 指针向后移。
o 指针向前移。
o 比较的大小。

在前面的算法中，指针是依赖于双向链表的，离开了这个特定的容器，我们无法确定指针的行为。那么我们可以对这里指针进行抽象，让它针对不同容器有不同的实现，而算法只关心它的指针这个接口。为了遵循一些约定俗成的规则，我们把这里的指针称为迭代器(iterator)。

迭代器(iterator)的接口定义如下：

typedef Ret  (*IteratorSetFunc)(Iterator* thiz, void* data);
typedef Ret  (*IteratorGetFunc)(Iterator* thiz, void** data);
typedef Ret  (*IteratorNextFunc)(Iterator* thiz);
typedef Ret  (*IteratorPrevFunc)(Iterator* thiz);
typedef Ret  (*IteratorAdvanceFunc)(Iterator* thiz, int offset);
typedef int  (*IteratorOffsetFunc)(Iterator* thiz);
typedef Ret  (*IteratorCloneFunc)(Iterator* thiz, Iterator** cloned);
typedef void (*IteratorDestroyFunc)(Iterator* thiz); 

struct _Iterator
{
    IteratorSetFunc     set;
    IteratorGetFunc     get;
    IteratorNextFunc    next;
    IteratorPrevFunc    prev;
    IteratorAdvanceFunc advance;
    IteratorCloneFunc   clone;
    IteratorOffsetFunc  offset;
    IteratorDestroyFunc destroy; 

    char priv[0];
};

为了让迭代器具有更广的适应能力，在其它算法也可以使用，这里增加了几个接口函数：

o advance 随机定位迭代器位置，由当前位置和偏移量决定。
o offset 得到迭代器的偏移量，主要用作比较迭代器的大小。
o clone拷贝一份迭代器。

现在我们来看针对双向链表的实现：

o 数据结构

typedef struct _PrivInfo
{
    DList* dlist;
    DListNode* cursor;
    int offset;
}PrivInfo;

一个指向双向链表的指针，它表明迭代器所属的容器。
一个指向当前结点的指针，它表明迭代器的位置。
一个标明当前偏移量的值，目的是提高获取偏移量的速度。

o 实现迭代器的函数

static Ret  dlist_iterator_set(Iterator* thiz, void* data)
{
    PrivInfo* priv = (PrivInfo*)thiz->priv;
    return_val_if_fail(priv->cursor != NULL && priv->dlist != NULL, RET_INVALID_PARAMS); 

    priv->cursor->data = data; 

    return RET_OK;
} 

static Ret  dlist_iterator_next(Iterator* thiz)
{
    Ret ret = RET_FAIL;
    PrivInfo* priv = (PrivInfo*)thiz->priv;
    return_val_if_fail(priv->cursor != NULL && priv->dlist != NULL, RET_INVALID_PARAMS); 

    if(priv->cursor->next != NULL)
    {
        priv->cursor = priv->cursor->next;
        priv->offset++; 

        ret = RET_OK;
    } 

    return ret;
} 

...

从这些代码可以看出，双向链表的迭代器其实就是对双向链表结点的包装，经过这个包装之后，可以访问具体的结点而又不暴露双向链表的内部实现，并且调用者不再依赖双向链表了。

o 创建函数

Iterator* dlist_iterator_create(DList* dlist)
{
    Iterator* thiz = NULL;
    return_val_if_fail(dlist != NULL, NULL); 

    if((thiz = malloc(sizeof(Iterator) + sizeof(PrivInfo))) != NULL)
    {
        PrivInfo* priv = (PrivInfo*)thiz->priv; 

        thiz->set      =  dlist_iterator_set;
        thiz->get      =  dlist_iterator_get;
        thiz->next     =  dlist_iterator_next;
        thiz->prev     =  dlist_iterator_prev;
        thiz->advance  =  dlist_iterator_advance;
        thiz->clone    =  dlist_iterator_clone;
        thiz->offset   =  dlist_iterator_offset;
        thiz->destroy  =  dlist_iterator_destroy; 

        priv->dlist  = dlist;
        priv->cursor = dlist->first;
        priv->offset = 0;
    } 

    return thiz;
}

这里我们还遇到另外一个难题：双向链表的迭代器的实现放在哪里？放在dlist.c里还是单独的文件里，放在单独的文件里可读性更强，但是在访问双向链表的内部数据时会遇到一些麻烦。最后选择是：

o dlist_iterator.h提供独立的文件。
o dlist_iterator.c也提供独立的文件，但是它不直接参与编译，而是在dlist.c里include它。

这样就两全其美了：维护方便又可以访问双向链表的内部数据结构。

最后我们来看看用迭代器实现的invert函数：

Ret invert(Iterator* forward, Iterator* backward)
{
    void* data1 = NULL;
    void* data2 = NULL;
    return_val_if_fail(forward != NULL && backward != NULL, RET_INVALID_PARAMS); 

    for(; iterator_offset(forward) < iterator_offset(backward); iterator_next(forward), iterator_prev(backward))
    {
        iterator_get(forward, &data1);
        iterator_get(backward, &data2);
        iterator_set(forward, data2);
        iterator_set(backward, data1);
    } 

    return RET_OK;
}

invert算法同时适用于双向链表和动态数组，而且它们的运行效率相差不大，至少对于双向链表来说已经是比较高效的实现了。

迭代器模式是一种重要的模式，在C＋＋的标准模板库(STL)中有大量的应用。老的C程序员通常是运行效率至上的，所以要在优雅的设计和性能之间做 出选择时，他们通常选择后者，所以很少看到C语言实现的容器提供迭代器，那也不足为奇。重要的是我们学习这种方法，并在适当的时候运用它。

本节示例代码请到这里下载。