模组化程式设计 是指程式核心部分定义好功能的界面，而具体的实现留给各个模组去做。举个现实世界的例子：我们可以在电脑的PCI插槽上安装显卡、声卡或者网络卡，原因就是这些硬件都按照PCI界面的规范来制造的。
模组化程式设计也一样，程式核心部分定义好界面，各个模组按照界面的定义去实现功能，然后把各个模组挂载到程式上即可，这个有点像Java的面向界面程式设计。如下图：
（图一）
模组化程式设计的好处就是最大化灵活性，程式的核心部分不用关心功能的具体实现，只需要呼叫模组提供的界面即可得到相应的结果。因为各个模组的具体实现各不相同，所以得到的结果也是多样化的。
使用C进行模组化程式设计
用过C语言程式设计的人都知道C语言是没有界面的，所以怎么使用C语言进行模组化程式设计呢？使用C语言的结构体和函式指标可以模拟出Java界面的特性，我们只需定义一个由多个函式指标构成的结构体，然后功能模组实现这个结构体里的函式即可。例如我们定义一个名为Car的结构体，而这个结构体有两个函式指标，分别是run()和stop()：
car.h
#ifndef __CAR_H
#define __CAR_H
struct Car
{
void (*run)();
void (*stop)();
};
#endif
从上面定义可以知道，实现了run()和stop()方法的模组都可以被称为Car（汽车）。现在我们来编写两个模组，分别是Truck和Van。
Truck模组如下（truck.c）：
#include
#include
#include car.h
static void run()
{
printf(I am Truck, running... );
}
static void stop()
{
printf(I am Truck, stopped... );
}
struct Car truck = {
.run = &run,
.stop = &stop,
};
Van模组如下（van.c）：
#include
#include
#include car.h
static void run()
{
printf(I am Van, running... );
}
static void stop()
{
printf(I am Van, stopped... );
}
struct Car van = {
.run = &run,
.stop = &stop,
};
这样我们编写了两个模组，一个是卡车模组（Truck），一个是客车模组（Van）。为了简单起见，我们只是简单的打印一段文字。现在可以说我们的车是变形金刚了，因为可以随时变成卡车或者客车（嘻嘻）。
我们把模组都写好了，但是怎么把模组应用到程式的核心部分呢？这时候我们需要一个注册机制。因为核心部分不知道我们到底编写了什么模组，所以就需要这个注册机制来告诉核心部分。注册机制很简单，只需要一个函式即可（main.c）：
#include car.h
extern struct Car van;
extern struct Car truck;
struct Car *car;
void register_module(struct Car *module)
{
car = module;
}
int main(int argc, char *argv[])
{
register_module(&truck);
car->run();
car->stop();
return 0;
}
编译执行后我们会得到以下的结果：
如果把 register_module(&truck); 改为 register_module(&van); 会得到以下结果：
从上面的结果可以看到，我们可以注册不同的模组来提供不同的服务，模组化程式设计就这样实现了。
Are you kidding me?
C的模组化程式设计的确是这么简单，但是我们可以实现更强大的功能：使用动态连结库来实现模组化。
使用动态连结库进行模组化程式设计
Linux提供一种叫动态连结库的技术（Windows也有类似的功能），可以通过系统API动态载入.so档案中的函式或者变数。动态连结库的好处是把程式划分成多个独立的部分编译，每个部分的编译互补影响。例如我们有动态连结库A、B、C，如果发现A有bug，我们只需要修改和重新编译A即可，而不用对B和C进行任何的改动。下面我们使用动态连结库技术来重写上面的程式。
其实要使用动态连结库技术，只需要把模组编译成.so档案，然后核心部分使用操作系统提供的dlopen()和dlsym()界面来载入模组即可。
1. 把模组编译成.so档案
首先我们修改van.c档案，主要是增加一个让核心部分获取模组界面的方法get_module()：
#include
#include
#include car.h
static void run()
{
printf(I am Van, running... );
}
static void stop()
{
printf(I am Van, stopped... );
}
struct Car module = {
.run = &run,
.stop = &stop,
};
sturct Car *get_module()
{
return &module;
}
然后我们需要把库的原始档编译成无约束位程式码。无约束位程式码是储存在主内存中的机器码，执行的时候与绝对地址无关。
$ gcc -c -Wall -Werror -fpic van.c
现在让我们将物件档案变成共享库。我们将其命名为van.so：
$ gcc -shared -o van.so van.o
这样我们就把van.c编译成动态连结库了。我们使用相同的方法把truck.c编译成truck.so。
2. 在核心部分载入动态连结库
使用动态连结库界面来修改核心部分程式码，如下：
#include Car.h
#include
#include
struct Car *car;
struct Car *register_module(char *module_name)
{
struct Car *(*get_module)();
void *handle;
handle = dlopen(module_name, RTLD_LAZY);
if (!handle) {
return NULL;
}
get_module = dlsym(handle, get_module);
if (dlerror() != NULL) {
dlclose(handle);
return NULL;
}
dlclose(handle);
return get_module();
}
int main(int argc, char *argv[])
{
struct Car *car;
if ((car = register_module(./van.so)) == NULL) {
return -1;
}
car->run();
car->stop();
return 0;
}
使用以下命令编译程式码：
$ gcc -rdynamic -o car main.c -ldl
执行程式后得到结果：
修改 register_module(./van.so) 为 register_module(./truck.so) 得到结果：
可以看到我们成功使用动态连结库改写了程式。
总结
由于模组化程式设计的灵活性和可扩充套件性非常好，所以很多流行的软件也提供模组化特性，如：Nginx、PHP和Python等。而这些软件使用的方法与本文介绍的大致相同，有兴趣可以检视这些软件的实现。
