练习19：一个简单的对象系统

原文：Exercise 19: A Simple Object System

译者：飞龙

我在学习面向对象编程之前学了C，所以它有助于我在C中构建面向对象系统，来理解OOP的基本含义。你可能在学习C之前就学了OOP语言，所以这章也可能会起到一种衔接作用。这个联系中，你将会构建一个简单的对象系统，但是也会了解更多关于C预处理器的事情。

这个练习会构建一个简单的游戏，在游戏中你会在一个小型的城堡中杀死弥诺陶洛斯，并没有任何神奇之处，只是四个房间和一个坏家伙。这个练习同时是一个多文件的项目，并且比起之前的一些程序看起来更像一个真正的C程序。我在这里介绍C预处理器的原因，是你需要它来在你自己的程序中创建多个文件。

C预处理器如何工作

C预处理器是个模板处理系统，它主要的用途是让C代码的编程更加容易，但是它通过一个语法感知的模板机制来实现。以前人们主要使用C预处理器来储存常量，以及创建“宏”来简化复杂的代码。在现代C语言中你会实际上使用它作为代码生成器来创建模板化的代码片段。

C预处理器的工作原理是，如果你给它一个文件，比如.c文件，它会处理以#（井号）字符开头的各种文本。当它遇到一个这样的文本时，它会对输入文件中的文本做特定的替换。C预处理器的主要优点是他可以包含其他文件，并且基于该文件的内容对它的宏列表进行扩展。

一个快速查看预处理器所做事情的方法，是对上个练习中的代码执行下列命令：

  1. cpp ex18.c | less

这会产生大量输出，但是如果你滚动它，会看到你使用#include包含的其他文件的内容。在原始的代码中向下滚动，你可以看到cpp如何基于头文件中不同的#define宏来转换代码。

C编译器与cpp的集成十分紧密，这个例子只是向你展示它是如何在背后工作的。在现代C语言中，cpp系统也集成到C的函数中，你或许可以将它当做C语言的一部分。

在剩余的章节中，我们会使用更多预处理器的语法，并且像往常一样解释它们。

原型对象系统

我们所创建的OOP系统是一个简单的“原型”风格的对象系统，很像JavaScript。你将以设置为字段的原型来开始，而不是类，接着将他们用作创建其它对象实例的基础。这个“没有类”的设计比起传统的基于类的对象系统更加易于实现和使用。

Object头文件

我打算将数据类型和函数声明放在一个单独的头文件中，叫做object.h。这个是一个标准的C技巧，可以让你集成二进制库，但其它程序员任然需要编译。在这个文件中，我使用了多个高级的C预处理器技巧，我接下来准备简略地描述它们，并且你会在后续的步骤中看到。

  1. #ifndef _object_h
  2. #define _object_h
  4. typedef enum {
  5.     NORTH, SOUTH, EAST, WEST
  6. } Direction;
  8. typedef struct {
  9.     char *description;
  10.     int (*init)(void *self);
  11.     void (*describe)(void *self);
  12.     void (*destroy)(void *self);
  13.     void *(*move)(void *self, Direction direction);
  14.     int (*attack)(void *self, int damage);
  15. } Object;
  17. int Object_init(void *self);
  18. void Object_destroy(void *self);
  19. void Object_describe(void *self);
  20. void *Object_move(void *self, Direction direction);
  21. int Object_attack(void *self, int damage);
  22. void *Object_new(size_t size, Object proto, char *description);
  24. #define NEW(T, N) Object_new(sizeof(T), T##Proto, N)
  25. #define _(N) proto.N
  27. #endif

看一看这个文件，你会发现我使用了几个新的语法片段，你之前从来没见过它们：

#ifndef

你已经见过了用于创建简单常量的#define，但是C预处理器可以根据条件判断来忽略一部分代码。这里的#ifndef是“如果没有被定义”的意思，它会检查是否已经出现过#define _object_h，如果已出现，就跳过这段代码。我之所以这样写，是因为我们可以将这个文件包含任意次，而无需担心多次定义里面的东西。

#define

有了上面保护该文件的#ifndef，我们接着添加_object_h的定义，因此之后任何试图包含此文件的行为，都会由于上面的语句而跳过这段代码。

#define NEW(T,N)

这条语句创建了一个宏，就像模板函数一样，无论你在哪里编写左边的代码，都会展开成右边的代码。这条语句仅仅是对我们通常调用的Object_new制作了一个快捷方式，并且避免了潜在的调用错误。在宏这种工作方式下，T、N还有New都被“注入”进了右边的代码中。T##Proto语法表示“将Proto连接到T的末尾”，所以如果你写下NEW(Room, "Hello.")，就会在这里变成RoomProto。

#define _(N)

这个宏是一种为对象系统设计的“语法糖”，将obj->proto.blah简写为obj->_(blah)。它不是必需的，但是它是一个接下来会用到的有趣的小技巧。

Object源文件

object.h是声明函数和数据类型的地方，它们在object.c中被定义（创建），所以接下来：

  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdlib.h>
  4. #include "object.h"
  5. #include <assert.h>
  7. void Object_destroy(void *self)
  8. {
  9.     Object *obj = self;
  11.     if(obj) {
  12.         if(obj->description) free(obj->description);
  13.         free(obj);
  14.     }
  15. }
  17. void Object_describe(void *self)
  18. {
  19.     Object *obj = self;
  20.     printf("%s.\n", obj->description);
  21. }
  23. int Object_init(void *self)
  24. {
  25.     // do nothing really
  26.     return 1;
  27. }
  29. void *Object_move(void *self, Direction direction)
  30. {
  31.     printf("You can't go that direction.\n");
  32.     return NULL;
  33. }
  35. int Object_attack(void *self, int damage)
  36. {
  37.     printf("You can't attack that.\n");
  38.     return 0;
  39. }
  41. void *Object_new(size_t size, Object proto, char *description)
  42. {
  43.     // setup the default functions in case they aren't set
  44.     if(!proto.init) proto.init = Object_init;
  45.     if(!proto.describe) proto.describe = Object_describe;
  46.     if(!proto.destroy) proto.destroy = Object_destroy;
  47.     if(!proto.attack) proto.attack = Object_attack;
  48.     if(!proto.move) proto.move = Object_move;
  50.     // this seems weird, but we can make a struct of one size,
  51.     // then point a different pointer at it to "cast" it
  52.     Object *el = calloc(1, size);
  53.     *el = proto;
  55.     // copy the description over
  56.     el->description = strdup(description);
  58.     // initialize it with whatever init we were given
  59.     if(!el->init(el)) {
  60.         // looks like it didn't initialize properly
  61.         el->destroy(el);
  62.         return NULL;
  63.     } else {
  64.         // all done, we made an object of any type
  65.         return el;
  66.     }
  67. }

这个文件中并没有什么新东西，除了一个小技巧之外。Object_new函数通过把原型放到结构体的开头，利用了structs工作机制的一个方面。当你在之后看到ex19.h头文件时，你会明白为什么我将Object作为结构体的第一个字段。由于C按顺序将字段放入结构体，并且由于指针可以指向一块内存，我就可以将指针转换为任何我想要的东西。在这种情况下，即使我通过calloc获取了一大块内存，我仍然可以使用Object指针来指向它。

当我开始编写ex19.h文件时，我会把它解释得更详细一些，因为当你看到它怎么用的时候才能更容易去理解它。

上面的代码创建了基本的对象系统，但是你需要编译它和将它链接到ex19.c文件，来创建出完整的程序。object.c文件本身并没有main函数，所以它不可能被编译为完整的程序。下面是一个Makefile文件，它基于已经完成的事情来构建程序：

  1. CFLAGS=-Wall -g
  3. all: ex19
  5. ex19: object.o
  7. clean:
  8.   rm -f ex19

这个Makefile所做的事情仅仅是让ex19依赖于object.o。还记得make可以根据扩展名构建不同的文件吗？这相当于告诉make执行下列事情：

  • 当我运行make时，默认的all会构建ex19。
  • 当它构建ex19时，也需要构建object.o，并且将它包含在其中。
  • make并不能找到object.o，但是它能发现object.c文件，并且知道如何把.c文件变成.o文件，所以它就这么做了。
  • 一旦object.o文件构建完成，它就会运行正确的编译命令，从ex19.c和object.o中构建ex19。

游戏实现

一旦你编写完成了那些文件，你需要使用对象系统来实现实际的游戏，第一步就是把所有数据类型和函数声明放在ex19.h文件中：

  1. #ifndef _ex19_h
  2. #define _ex19_h
  4. #include "object.h"
  6. struct Monster {
  7.     Object proto;
  8.     int hit_points;
  9. };
  11. typedef struct Monster Monster;
  13. int Monster_attack(void *self, int damage);
  14. int Monster_init(void *self);
  16. struct Room {
  17.     Object proto;
  19.     Monster *bad_guy;
  21.     struct Room *north;
  22.     struct Room *south;
  23.     struct Room *east;
  24.     struct Room *west;
  25. };
  27. typedef struct Room Room;
  29. void *Room_move(void *self, Direction direction);
  30. int Room_attack(void *self, int damage);
  31. int Room_init(void *self);
  34. struct Map {
  35.     Object proto;
  36.     Room *start;
  37.     Room *location;
  38. };
  40. typedef struct Map Map;
  42. void *Map_move(void *self, Direction direction);
  43. int Map_attack(void *self, int damage);
  44. int Map_init(void *self);
  46. #endif

它创建了三个你将会用到的新对象：Monster，Room，和Map。

看一眼object.c:52，你可以看到这是我使用Object *el = calloc(1, size)的地方。回去看object.h的NEW宏，你可以发现它获得了另一个结构体的sizeof，比如Room，并且分配了这么多的空间。然而，由于我像一个Object指针指向了这块内存，并且我在Room的开头放置了Object proto，所以就可以将Room当成Object来用。

详细分解请见下面：

  • 我调用了NEW(Room, "Hello.")，C预处理器会将其展开为Object_new(sizeof(Room), RoomProto, "Hello.")。
  • 执行过程中，在Object_new的内部我分配了Room大小的一块内存，但是用Object *el来指向它。
  • 由于C将Room.proto字段放在开头，这意味着el指针实际上指向了能访问到完整Object结构体的，足够大小的一块内存。它不知道这块内存叫做proto。
  • 接下来它使用Object *el指针，通过*el = proto来设置这块内存的内容。要记住你可以复制结构体，而且*el的意思是“el所指向对象的值”，所以整条语句意思是“将el所指向对象的值赋为proto”。
  • 由于这个谜之结构体被填充为来自proto的正确数据，这个函数接下来可以在Object上调用init，或者destroy。但是最神奇的一部分是无论谁调用这个函数都可以将它们改为想要的东西。

结合上面这些东西，我就可以使用这一个函数来创建新的类型，并且向它们提供新的函数来修改它们的行为。这看起来像是“黑魔法”，但它是完全有效的C代码。实际上，有少数标准的系统函数也以这种方式工作，我们将会用到一些这样的函数在网络程序中转换地址。

编写完函数定义和数据结构之后，我现在就可以实现带有四个房间和一个牛头人的游戏了。

  1. #include <stdio.h>
  2. #include <errno.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <time.h>
  6. #include "ex19.h"
  9. int Monster_attack(void *self, int damage)
  10. {
  11.     Monster *monster = self;
  13.     printf("You attack %s!\n", monster->_(description));
  15.     monster->hit_points -= damage;
  17.     if(monster->hit_points > 0) {
  18.         printf("It is still alive.\n");
  19.         return 0;
  20.     } else {
  21.         printf("It is dead!\n");
  22.         return 1;
  23.     }
  24. }
  26. int Monster_init(void *self)
  27. {
  28.     Monster *monster = self;
  29.     monster->hit_points = 10;
  30.     return 1;
  31. }
  33. Object MonsterProto = {
  34.     .init = Monster_init,
  35.     .attack = Monster_attack
  36. };
  39. void *Room_move(void *self, Direction direction)
  40. {
  41.     Room *room = self;
  42.     Room *next = NULL;
  44.     if(direction == NORTH && room->north) {
  45.         printf("You go north, into:\n");
  46.         next = room->north;
  47.     } else if(direction == SOUTH && room->south) {
  48.         printf("You go south, into:\n");
  49.         next = room->south;
  50.     } else if(direction == EAST && room->east) {
  51.         printf("You go east, into:\n");
  52.         next = room->east;
  53.     } else if(direction == WEST && room->west) {
  54.         printf("You go west, into:\n");
  55.         next = room->west;
  56.     } else {
  57.         printf("You can't go that direction.");
  58.         next = NULL;
  59.     }
  61.     if(next) {
  62.         next->_(describe)(next);
  63.     }
  65.     return next;
  66. }
  69. int Room_attack(void *self, int damage)
  70. {
  71.     Room *room = self;
  72.     Monster *monster = room->bad_guy;
  74.     if(monster) {
  75.         monster->_(attack)(monster, damage);
  76.         return 1;
  77.     } else {
  78.         printf("You flail in the air at nothing. Idiot.\n");
  79.         return 0;
  80.     }
  81. }
  84. Object RoomProto = {
  85.     .move = Room_move,
  86.     .attack = Room_attack
  87. };
  90. void *Map_move(void *self, Direction direction)
  91. {
  92.     Map *map = self;
  93.     Room *location = map->location;
  94.     Room *next = NULL;
  96.     next = location->_(move)(location, direction);
  98.     if(next) {
  99.         map->location = next;
  100.     }
  102.     return next;
  103. }
  105. int Map_attack(void *self, int damage)
  106. {
  107.     Map* map = self;
  108.     Room *location = map->location;
  110.     return location->_(attack)(location, damage);
  111. }
  114. int Map_init(void *self)
  115. {
  116.     Map *map = self;
  118.     // make some rooms for a small map
  119.     Room *hall = NEW(Room, "The great Hall");
  120.     Room *throne = NEW(Room, "The throne room");
  121.     Room *arena = NEW(Room, "The arena, with the minotaur");
  122.     Room *kitchen = NEW(Room, "Kitchen, you have the knife now");
  124.     // put the bad guy in the arena
  125.     arena->bad_guy = NEW(Monster, "The evil minotaur");
  127.     // setup the map rooms
  128.     hall->north = throne;
  130.     throne->west = arena;
  131.     throne->east = kitchen;
  132.     throne->south = hall;
  134.     arena->east = throne;
  135.     kitchen->west = throne;
  137.     // start the map and the character off in the hall
  138.     map->start = hall;
  139.     map->location = hall;
  141.     return 1;
  142. }
  144. Object MapProto = {
  145.     .init = Map_init,
  146.     .move = Map_move,
  147.     .attack = Map_attack
  148. };
  150. int process_input(Map *game)
  151. {
  152.     printf("\n> ");
  154.     char ch = getchar();
  155.     getchar(); // eat ENTER
  157.     int damage = rand() % 4;
  159.     switch(ch) {
  160.         case -1:
  161.             printf("Giving up? You suck.\n");
  162.             return 0;
  163.             break;
  165.         case 'n':
  166.             game->_(move)(game, NORTH);
  167.             break;
  169.         case 's':
  170.             game->_(move)(game, SOUTH);
  171.             break;
  173.         case 'e':
  174.             game->_(move)(game, EAST);
  175.             break;
  177.         case 'w':
  178.             game->_(move)(game, WEST);
  179.             break;
  181.         case 'a':
  183.             game->_(attack)(game, damage);
  184.             break;
  185.         case 'l':
  186.             printf("You can go:\n");
  187.             if(game->location->north) printf("NORTH\n");
  188.             if(game->location->south) printf("SOUTH\n");
  189.             if(game->location->east) printf("EAST\n");
  190.             if(game->location->west) printf("WEST\n");
  191.             break;
  193.         default:
  194.             printf("What?: %d\n", ch);
  195.     }
  197.     return 1;
  198. }
  200. int main(int argc, char *argv[])
  201. {
  202.     // simple way to setup the randomness
  203.     srand(time(NULL));
  205.     // make our map to work with
  206.     Map *game = NEW(Map, "The Hall of the Minotaur.");
  208.     printf("You enter the ");
  209.     game->location->_(describe)(game->location);
  211.     while(process_input(game)) {
  212.     }
  214.     return 0;
  215. }

说实话这里面并没有很多你没有见过的东西，并且你只需要理解我使用头文件中宏的方法。下面是需要学习和理解的一些重要的核心知识：

  • 实现一个原型涉及到创建它的函数版本，以及随后创建一个以“Proto”结尾的单一结构体。请参照MonsterProto，RoomProto和MapProto。
  • 由于Object_new的实现方式，如果你没有在你的原型中设置一个函数，它会获得在object.c中创建的默认实现。
  • 在Map_init中我创建了一个微型世界，然而更重要的是我使用了object.h中的NEW宏来创建全部对象。要把这一概念记在脑子里，可以试着把使用NEW的地方替换成Object_new的直接调用，来观察它如何被替换。
  • 使用这些对象涉及到在它们上面调用函数，_(N)为我做了这些事情。如果你观察代码monster->_(attack)(monster, damage)，你会看到我使用了宏将其替换成monster->proto.attack(monster, damage)。通过重新将这些调用写成原始形式来再次学习这个转换。另外，如果你被卡住了，手动运行cpp来查看究竟发生了什么。
  • 我使用了两个新的函数srand和rand，它们可以设置一个简单的随机数生成器，对于游戏已经够用了。我也使用了time来初始化随机数生成器。试着研究它们。
  • 我使用了一个新的函数getchar来从标准输入中读取单个字符。试着研究它。

你会看到什么

下面是我自己的游戏的输出：

  1. $ make ex19
  2. cc -Wall -g   -c -o object.o object.c
  3. cc -Wall -g    ex19.c object.o   -o ex19
  4. $ ./ex19
  5. You enter the The great Hall.
  7. > l
  8. You can go:
  9. NORTH
  11. > n
  12. You go north, into:
  13. The throne room.
  15. > l
  16. You can go:
  17. SOUTH
  18. EAST
  19. WEST
  21. > e
  22. You go east, into:
  23. Kitchen, you have the knife now.
  25. > w
  26. You go west, into:
  27. The throne room.
  29. > s
  30. You go south, into:
  31. The great Hall.
  33. > n
  34. You go north, into:
  35. The throne room.
  37. > w
  38. You go west, into:
  39. The arena, with the minotaur.
  41. > a
  42. You attack The evil minotaur!
  43. It is still alive.
  45. > a
  46. You attack The evil minotaur!
  47. It is dead!
  49. > ^D
  50. Giving up? You suck.
  51. $

审计该游戏

我把所有assert检查留给你作为练习，我通常把它们作为软件的一部分。你已经看到了我如何使用assert来保证程序正确运行。然而现在我希望你返回去并完成下列事情：

  • 查看你定义的每个函数，一次一个文件。
  • 在每个函数的最上面，添加assert来保证参数正确。例如在Object_new中要添加assert(description != NULL)。
  • 浏览函数的每一行，找到所调用的任何函数。阅读它们的文档（或手册页），确认它们在错误下返回什么。添加另一个断言来检查错误是否发生。例如，Object_new在调用calloc之后应该进行assert(el != NULL)的检查。
  • 如果函数应该返回一个值，也确保它返回了一个错误值（比如NULL），或者添加一个断言来确保返回值是有效的。例如，Object_new中，你需要在最后的返回之前添加assert(el != NULL)，由于它不应该为NULL。
  • 对于每个你编写的if语句，确保都有对应的else语句，除非它用于错误检查并退出。
  • 对于每个你编写的switch语句，确保都有一个default分支，来处理非预期的任何情况。

花费一些时间浏览函数的每一行，并且找到你犯下的任何错误。记住这个练习的要点是从“码农”转变为“黑客”。试着找到使它崩溃的办法，然后尽可能编写代码来防止崩溃或者过早退出。

附加题

  • 修改Makefile文件，使之在执行make clean时能够同时清理object.o。
  • 编写一个测试脚本，能够以多种方式来调用该游戏，并且扩展Makefile使之能够通过运行make test来测试该游戏。
  • 在游戏中添加更多房间和怪物。
  • 把游戏的逻辑放在其它文件中，并把它编译为.o。然后，使用它来编写另一个小游戏。如果你正确编写的话，你会在新游戏中创建新的Map和main函数。