冒号和他的学生们（连载23）——数据抽象

冒号和他的学生们（连载23）——数据抽象

 

冒号和他的学生们

——程序员提高班纪事

 

23．数据抽象

善张网者引其纲，不一一摄万目而后得            ——《韩非子·外储说右下》

  

问号抢着说：“我知道了：过程抽象的结果是函数，数据抽象的结果应该是数据类型。”

冒号首肯：“数据类型与数据运算是程序语言的基本要素，除了内建的类型与运算外，程序语言还提供了用户定义（user-defined）的扩展机制，以提高编程者的效率。正如函数是一些基本运算的复合，自定义类型通常是一些基本类型的复合。不过单纯的复合类型并不是真正意义上的数据抽象，我们关注的是抽象数据类型（ADT）。”

逗号说了句老实话：“学数据结构时常提到抽象数据类型，但二者究竟什么关系还真没搞明白。”

冒号解析道：“作为数据与运算的有机集合体，它们可看作同一事物的两个方面。数据结构强调具体实现，侧重应用；抽象数据类型强调抽象接口，侧重设计。比如栈、队列、链表、二叉树等作为数据结构，人们关心的是如何利用它们有效地组织数据；而作为抽象数据类型，人们更关心的是类型的设计及其背后的数学模型。”

引号推想：“既然有抽象数据类型，想必就有具体数据类型吧？”

“这是当然。”冒号肯定道，“具体数据类型主要用于数据储存，除了getter和setter之外没有其他的运算。例如由省、市、街道和邮编组成的通讯地址便是一个典型的具体类型，谁能告诉我定义这种类型的意义？”

句号回答：“定义这种类型可以绑定省、市、街道和邮编这四个相关的数据，便于统一管理，包括创建、复制、作为参数传递或作为函数返回值等等。”

“说得不错！”冒号满意地点点头，“J2EE中常用一种设计模式：数据传输对象（Data Transfer Objects或DTO），又称值对象（Value Object或VO），这类对象不含任何业务逻辑，仅仅作为简单的数据容器，实质上也属于具体数据类型。”

“究竟这里的‘具体’具体在哪里，‘抽象’又抽象在哪里？”叹号的眼前飘浮的迷雾也是那么具体而抽象。

冒号轻轻拨开雾霭：“如果一个数据类型依赖于其具体实现，它就是具体的，反之则是抽象的。再拿通讯地址为例，它所有的域即省、市、街道和邮编对于客户都应该是透明的——至于是通过getter、setter还是直接访问并无本质区别，如此用户才能有针对性地进行数据储存、传递和获取。如果对该类型进行修改，比如增加一个代表国家的域或者减少代表邮编的域，必须知会用户，否则毫无意义。显然这种类型与实现细节密切相关，因而是具体的。作为抽象类型的例子，让我们看看队列（Queue）吧。队列是一种非常基本的数据结构，广泛应用于操作系统、网络和现实生活中。请问它的特征是什么？”

引号最擅长这类问题：“队列的特征是先进先出（FIFO）——每次数据只能从队尾加入，从队首移除。”

“好的。队列一般至少包括类似数据库的CRUD（增删改查）操作：创建操作——建队；删除操作——撤队；修改操作——入队、出队；查询操作——是否为空队、队列长度、队首。下面我们用C来表述队列的操作接口。”冒号投影出一段代码——

typedef  char  ItemType;          /*  队列成员的数据类型，char可换成其他类型   */

/*  QueueType待定。。。  */

typedef QueueType *  Queue;

/* * 初始化队列。成功返回0，否则返回-1。 */
int  queue_initialize(Queue);

/* * 终结化队列  */
void  queue_finalize(Queue);

/* * 加入队列尾部。成功返回0，否则返回-1。 */
int  queue_add(Queue, ItemType);

/* * 移除队列头部。成功返回0，否则返回-1。 */
int  queue_remove(Queue, ItemType * );

/* * 队列是否为空？ */
int  queue_empty(Queue);

/* * 队列长度  */
int  queue_length(Queue);

/* * 返回（但不移除）队列头部。成功返回0，否则返回-1。  */
int  queue_head(Queue, ItemType * );

冒号解释：“特意用C语言是为了表明ADT不独OOP专有。由于C不支持异常（exception），因此用非零返回值来表示错误发生。我们尚未定义队列类型QueueType，其核心是队列的成员集合。无论是用数组来实现，还是用链表来实现，用户根本不需关心。这便是队列的抽象所在——用户不应知道也不必知道它的具体实现，只能通过指定接口来进行‘暗箱操作’。这样经过数据抽象，队列的本质特征由API展现，非本质特征则屏蔽于客户的视野之外。”

问号问道：“这种数据抽象与前面提到的参数抽象和规范抽象有何关系？”

“参数抽象使得数据接口普适化，规范抽象使得数据接口契约化。”冒号的回答简明扼要，“此外，一个完整的数据抽象除了对每个接口作规范说明外，还需对该数据类型作整体规范说明，OOP中的类注释文档即作此用。”

逗号要求：“能不能给出完整的实现代码？光有接口没实现，似乎不太过瘾。”

冒号戏言：“我感觉你在把程序当烟抽——光有烟嘴的接口，没有香烟的实现，的确不太过瘾。”

众笑。

冒号借题发挥：“许多程序员都有一个通病：重实现，轻接口。在编写代码时表现为：不等接口设计好就技痒难忍，揎拳捋袖地开始大干；在阅读代码时表现为：看到API文档便恹恹欲睡，看到代码便两眼放光。务必谨记：接口是纲，实现是目。纲若不举，目无以张。也就是常说的：‘Programming to an Interface, not an Implementation’。不过为满足你们的要求，我还是写了一段基于循环数组的实现代码。”

逗号正感当靶子的滋味不好受，一见代码便心旌摇荡，宠辱皆忘了。

/* 队列类型定义*/

typedef  struct
{
    ItemType* data;         /**//* 队列成员数据  */
    int first;                      /**//* 队首位置 */
    int last;                       /**//* 队尾位置 */
    int count;                    /**//* 队列长度 */
    int size;                       /**//* 队列容量 */ 
}  QueueType;

 /* 文件QueueImpl.c：队列的循环数组（circular array）实现 */

int  queue_initialize(Queue q)
{
    int size = 100;             /**//* 初始容量 */
    q->size = size;
    q->data = (ItemType*)malloc(sizeof(ItemType) * size);
    if (q->data == NULL) return -1; /**//* 内存不足 */

    q->first = 0;
    q->last = -1;
    q->count = 0;
    return 0;
}

void  queue_finalize(Queue q)
{
    free(q->data);
    q->data = NULL;
    q->first = 0;
    q->count = 0;
}

int  queue_empty(Queue q)
{
    return q->count <= 0;
}

int  queue_length(Queue q)
{
    return q->count;
}

/**/ /* （内部函数）扩大队列容量 */
static   int  queue_resize(Queue q)
{
    int oldSize = q->size;
    int newSize = oldSize * 2;
    int newIndex;
    int oldIndex = q->first;
    ItemType* data = (ItemType*)malloc(sizeof(ItemType) * newSize);

    if (data == NULL) return -1; /**//* 内存不足 */

    for (newIndex = 0; newIndex < q->count; ++newIndex) /**//* 复制到新数组  */
    {
        data[newIndex] = q->data[oldIndex];
        oldIndex = (oldIndex + 1) % oldSize;
    }

    free(q->data);
    q->data = data;
    q->first = 0;
    q->last = oldSize - 1;
    q->size = newSize;
    return 0;
}

int  queue_add(Queue q, ItemType item)
{
    if (q->count >= q->size) /**//* 超出容量后自动扩容 */
    {
        if (queue_resize(q) < 0) return -1;   /**//* 内存不足 */
    }

    q->last = (q->last + 1) % q->size;
    q->data[q->last] = item;    
    ++q->count;
    return 0;
}

int  queue_remove(Queue q, ItemType *  item)
{
    if (q->count <= 0) return -1;

    *item = q->data[q->first];
    q->first = (q->first + 1) % q->size;
    --q->count;
    return 0;
}

int  queue_head(Queue q, ItemType *  item)
{
    if (q->count <= 0) return -1;

    *item = q->data[q->first];
    return 0;
}

 

“由于函数queue_resize并非公共接口，因此前面加上static，以避免被外部调用。与Java中的涵义不同，C中static函数表示文件内部函数。作为对比，我们再看看队列的链表实现。”冒号说罢投影出另两段代码——

/* 队列类型定义*/

typedef  struct  NodeType
{
    ItemType item;                  /**//* 队列成员数据 */
    struct NodeType* next;
}  NodeType;

typedef NodeType *  Node;

typedef  struct
{
    Node head;                      /**//* 队首 */
    Node tail;                       /**//* 队尾 */
    int count;                       /**//* 队列长度 */
}  QueueType;

/* 文件QueueImpl.c：队列的链表（linked list）实现 */

int  queue_initialize(Queue q)
{
    q->head = NULL;
    q->tail = NULL;
    q->count = 0;
    return 0;
}

void  queue_finalize(Queue q)
{
    ItemType item;
    while (queue_remove(q, &item) >= 0)
        ;
}

int  queue_empty(Queue q)
{
    return q->count <= 0;
}

int  queue_length(Queue q)
{
    return q->count;
}

int  queue_add(Queue q, ItemType item)
{
    Node node = (Node)malloc(sizeof(NodeType));
    if (node == NULL) return -1; /**//* 内存不足 */

    node->item = item;
    node->next = NULL;
    if (q->tail)
    {
        q->tail->next = node;
        q->tail = node;
    }
    else
    {
        q->head = q->tail = node;
    }
    ++q->count;
    return 0;
}

int  queue_remove(Queue q, ItemType *  item)
{
    Node oldHead = q->head;
    if (q->count <= 0) return -1;

    *item = oldHead->item;
    q->head = oldHead->next;
    free(oldHead);
    if (--q->count == 0)
    {
        q->tail = NULL;
    }
    return 0;
}

int  queue_head(Queue q, ItemType *  item)
{
    if (q->count <= 0) return -1;

    *item = q->head->item;
    return 0;
}

   

叹号发现：“两种实现方式看起来迥然不同啊。”

“不同的内部数据结构，导致不同的算法。正是注意到这一点，人们多采取‘整体设计以数据为中心，局部实现以算法为中心’的方针，以增强系统的可维护性。最后看看示例客户代码。”冒号继续放幻灯——
    /* 客户测试代码 */

QueueType queue;
Queue q  =   & queue;
char  item;
int  i;

queue_initialize(q);
for  (i  =   0 ; i  <   26 ;  ++ i)  /**/ /* 将26个字母加入队列 */
{
    queue_add(q, 'a' + i);
}

printf( " Queue is %s\n " , queue_empty(q)  ?   " empty "  :  " nonempty " );
printf( " Queue length = %d\n " , queue_length(q));

while  (queue_remove(q,  & item)  ==   0 )  /**/ /* 一一出队 */
{
    printf("removing queue item:[%c].\n", item);
}

printf( " Queue is %s\n " , queue_empty(q)  ?   " empty "  :  " nonempty " );
queue_finalize(q);

 

冒号指出：“尽管两种实现方式大相径庭，客户代码却毫无二致。这种数据类型的接口与实现的分离，有利于开发时间的分离以及开发人员的分离。开发时间的分离指的是：开发人员可以推迟在不同实现方式中作抉择，以保证整体开发进程；开发人员的分离指的是：程序的修改和维护不局限于原作者。”

问号发现一个问题：“C语法中没有private关键词，用户仍然有权访问和修改队列的域成员，整个代码逻辑有可能被破坏。”

“没错。但作为一个合格的程序员，写出的代码不仅要合法，还要合理。”冒号掷地有声，“合法指合乎语法，合理指合乎语义。既然用到队列这个数据结构，当然要遵循其使用规范。打个比方，法律只是维护社会秩序的最低限度的规范，一个只遵守法律而不遵守通用规范的人必定与社会格格不入。从另一个角度看，假设所有程序员都是遵守规范的，那么类似C这种非OOP语言，只要将数据抽象与过程抽象有机结合，同样具有与OOP不相上下的可维护性和可重用性。”

引号有些困惑：“OOP中的类是否就是ADT？”

冒号释疑：“可以将类理解为具有继承和多态机制的ADT。但严格说来，并不是所有的类都有抽象性，比如前面提到的仅作存储用的值对象。在C#中有值类型与引用类型之分，分别用struct和class的关键字来指明。可以把ADT作为选择原则：是ADT则采用引用类型，否则采用值类型。C++中struct与class在机制上没有区别，只是前者成员缺省为public而后者缺省为private。但习惯上也是前者作具体类型，后者作抽象类型。Java和C中没有类似的区分，一个只支持class，一个只支持struct。”

句号沉吟半晌，忽道：“能不能这样总结一下抽象数据类型？抽象——接口与实现相分离；数据——以数据为中心组织逻辑；类型——单纯而定义良好的概念。”

“精辟！”冒号赞赏有加，“许多人能将OOP中的封装、继承和多态说得头头是道，用得得心应手，便自认为精通OOP了。殊不知抽象——尤其是数据抽象——才是OOP的核心和起源，尽管它们并非OOP的专利。没有抽象作基础，封装、继承和多态尽皆无本之木。只有贯彻ADT思想，设计出来的类才会是‘万人迷’：有优雅的外形——抽象，有丰富的内涵——数据，有鲜明的个性——类型。”

附：示例源代码下载(queue.rar)