本文翻译自Dr. Dobb's杂志主编Andrew Binstock的文章“Why Code in C Anymore?”，以下是翻译正文。

传统的那些选择C而不是C++的理由的说服力已经逐渐地被削弱。还有什么继续使用C的更好的理由么？

一个 Dr. Dobb's的老读者最近问我：为何人们还在使用C编程。这个话题最近曾在我们站点的评论中出现过。早期也曾出现在与一些行业公司的对话过程中，尤其是微 软。在C++早期，根据你的需要，你可以有许多使用C或C++的理由；但随着C++的演化，C的大量传统的杰出特性已经变得不那么优越了。考虑到 这些点一般是在比较两门编程语言时首先会被考虑到的，因此我们来一起看一下。

性能。通常我们都认为C++应用的性能要比C的慢。但在大多主流平台上，这个性能上的差距在今天已经变得非常小了。比 如，Alioth上的计算机基准测试报告显示C++(运行在32位Linux上)在运行基准测试时的性能要比C慢27%。其他一些研究结果显示这个差 距或略大或略小些。但在几乎所有例子中，C++都是仅次于C的运行第二快的编程语言。它通常要比运行在JVM和.NET平台上的语言快出很多。因 此，尽管C在基准测试上依旧保持有优势，但对于大多已经可以接受Java性能的应用(比如企业应用或面向客户端的应用)而言，这个差距显得并不是那么重要 了。

普遍性。在嵌入式编程领域，C仍然保持着首选语言的舒适地位，这缘于这样一个事实：每个硬件供货商都会提供一个C编译器。而大家普遍 也认为C++在嵌入式开发方面表现没有那么强势。不过，当今大多提供编程工具的组件供货商也提供了C++编译器。(但PIC微控制器方面继续保持 着例外)。这是一个正在逐渐缩水的好处。

可移植性。C++曾被认为是一个可移植的老大难（实际上在C89标准出台以前，C也是一个老大难）。然而，当今的编译器对C++语 言的核心实现的十分充分，以至于大多软件可以通过重新编译进行移植，不需要什么调整。如果真的需要进行调整的话，请提供像Brian Kernighan曾经说过的那样的使用语言中段的代码（译注：所谓语言中段的代码，即那些平台无关，不涉及可移植性的代码语法和元素）。库的可移植 性是一个更令人头疼的因素，不过C库也存在同样的问题。在C和C++中，编译器的标准遵守程度迥异，因此使用那些没有获得全面支持的新特性 (C99、C11以及C++11）将会是一个内在的风险。也就是说，C89可能是世界上最具可移植性的代码了。(为此，当可移植性成为最关心的事 情的时候，我们将选择它。例如，Lua团队就因此选择了C，当然也同样考虑到了性能因素)

应该说从性能、普遍性以及可移植性方面来讲，C仍然对C++保持着优势，但这种优势正在逐步缩小。在这点上，C++社区做得非常出色，他们让用户 去处理那些实质性问题并采纳。问题是：这些缩水的优势对C++的好处是种补偿吗？这些好处包括面向对象，异常处理，更好的类型管理，模板，更丰富 的标准库等等。没有了这些好处，每个用C实现的工程可能感觉起来就像尝试用一柄剪刀去修剪草坪。

那些特性无疑有助于代码编写，但却要因此付出代价 – 复杂性，这也是C有别于C++的重要之处。C是为数不多的几种规模短小、足够简洁的通用编程语言，你可以轻松掌握其全部内容。事实上我们确实可能需要 完整地了解一门语言的全部细节，并且还要充分了解其标准库，达到无需查看API手册即可使用的程度。我不相信这在其他主流语言中是可行的，C++，当然不行。

短小是语言的吸引力之一。你可以快速学习它并快速成为有效率的开发者。简洁则因另一个较少被谈及的特性而被提高：极致的语言可读性。我这里指的是 语义上而不是语法上的。在语义方面，C中做某件事情的方法是有限的。因此，当你阅读代码时，无论是谁编写的代码，你会确切地知道代码的行为。相反，C++ 做同一件事情有很多种方法 – C++开发者喜欢的一种灵活性。正是由于C在这方面的清晰，它才成为一门用于编写复杂基础设施的卓越编程语言。也正是这个原因，JRockit JVM（现在Oracle的主要JVM）的原始作者选择了C。在几年前的一段对话中，他们阐述了他们选择C而不是C++的观点：他们可以更快速获得开发 者；当深入到代码中时，他们可以比使用C++更容易地理解这些代码。

仅凭这一点，C语言仍然是系统层代码的一个极佳选择：它快速，可移植，易于阅读和理解。对于那些更加强调开发效率的应用，无疑C++将继续在原生语言中占据主导位置，并且很可能扩大其足迹。

Go语言中引入了一个新的关键字defer，个人认为这个语法关键字让异常处理也变得得心应手许多，对改善代码的可读性和可维护性大有裨益，是典型的语法棒棒糖^_^。

像下面这种代码（伪代码）：

void foo() {
    apply resource1;

    retv = action1;
    if not success
        release resource1

    apply resource2;

    retv = action2;
    if not success
        release resource1
        release resource2
}

有了defer后，代码就变得优美多了。

void foo_with_defer() {
    apply resource1;
    defer (release_resource1)

    retv = action1;
    if not success
        return

    apply resource2;
    defer (release_resource2)

    retv = action2;
    if not success
        return
}

如果能在C语言中实现defer这样的语法糖，那该多棒！是否可行呢？经过一段时间钻研，找到一个不那么美的实现方法，约束也很多，也不甚严谨， 谈不上什么可移植性，切不可用到产品环境，权当一种探讨罢了。

Go中defer的语义大致是这样的：
* 在使用defer的函数退出前，defer后面的函数将会被执行；
* 如果一个函数内有多个defer，那么defer按后进先出（LIFO）的顺行执行；
* 即使发生Panic，defer依然可以得到执行

最后一个比较难于模拟，这里仅先尝试前两个语义。下面从设计思路说起。

* “借东风”

要想模拟defer，首先要考虑的一点那就是defer后的语句是在函数return之前执行的。在标准C中，我们无任何举措可以实现这些。要在 C中实现defer，势必要借用一些编译器扩展特性，比如Gcc的扩展。这里实验所使用的编译器是Gcc(4.6.3 (Ubuntu 12.04))。Gcc扩展支持-finstrument-functions编译选项，该选项可以在函数执行前后插入一段运行代码。在之前写过的一篇名 为“为函数添加enter和exit级trace”的文章中对此有较为详细的说明，这里我们还要用到这个扩展特性。

* 偷天换日

如果完全模仿Go的语法，在C中使用defer，大致是这样一种形式：

void foo(void) {
    FILE * fp = NULL;
    fp = fopen("foo.txt", "r");
    if (!fp) return;
    defer(fclose(fp));
   
    /* use fp */
    … …
    return;
}

但C毕竟是C，一门静态的编译型语言，我们如何将fclose(fp)这个信息传递给编译器自动插入的代码中呢？在C语言中，几乎没有手段获得函 数的元信息以及运行时参数信息，并再通过这些信息重新调用和执行该函数。我们得“想招”将这些信息存储起来。

大家知道C语言中的函数，比如这里的fclose，其实是一个函数起始地址；如果我们知道函数地址或又叫函数指针，再加上函数的参数，我们就可以 拼凑在一起执行该函数了。但理论上来说，函数指针也是有类型的，比如：

typedef int (*FUNC_POINTER)(int, int);

这个函数指针类型可以用来执行诸如：int foo(int a, int b)这样的函数，比如：

FUNC_POINTER fp = foo；
fp(1, 2);

但defer后面执行的函数千差万别，我们如何能够得知函数对应的函数指针类型呢？用void*存储？比如：

void *p = foo;
p(1, 2);

编译器会给你一个严重错误！p不是函数指针，不能这么用。那我们如何能让编译器知道这个指针是一个可调用的函数指针呢？我们试试来定义一个“通用 的函数指针”：

typedef void (*defer_func)();

没有返回值，没有参数，这样的函数指针能否执行foo这样的函数呢？答案是可以的，但不是那么完美。至少你不会得到返回值。这么做有两点考虑：
a) 至少可以让编译器知道这是一个函数指针，可以被用来执行函数。
b) 通常我们并不关心defer后面函数的返回值。
c) 参数列表的不同至少目前可以逃过编译器的错误检查，至多给个Warning。

函数指针的问题暂时算是有着落了，那参数怎么办？也就是说defer(fclose(fp))中的fp如何存储下来呢？如果在C中真的使用 defer(fclose(p))这种形式的语法，那么我是砸破脑袋也想不出啥招了！因此我们应该重新设计一下C中的defer应该如何使用？我 们用下面的语法来替代：

defer(fclose, 1, p);

fclose是函数起始地址，1是参数个数，p则是传给fclose的参数。这样fclose和p都可以单独分离出来存储了。但是还是那句 话：defer后面可以执行的函数千万种，哪能穷尽？怎么才能表示成一种通用的方式存储参数呢？回想一下自己在编码过程中用于释放资源的那几类函 数，无非就是关闭文件、关闭文件描述符(包括socket)、释放内存等，这些函数传递的参数不是指针就是整型数，少有传浮点类型或将一个自定义 结构体以传值的方式传入的。我们不妨再次尝试一次“偷天换日” – 用void*存储整型参数或任意指针类型参数。当然其约束就像刚才所说的那些。不过对付大多数资源释放函数而言，应该是足够的了。至于将参数个数也作为一 个固定参数放入defer中，也是鉴于目前无法通过操作可变个数参数列表相关宏来获得参数数量。

最后一个问题。由于被defer的函数的参数个数不定。defer无法将可变个数参数重组后传给被defer的函数。因此目前暂只能通过一种“丑陋”的方式来实现。样例中最多只支持两个参数的被defer函数。

* 样例

首先看看我们的examples的主函数文件main.c。

#include <stdio.h>
#include <stdlib.h>
#include "defer.h"

int bar(int a, char *s) {
    printf("a = [%d], s = [%s]\n", a, s);
}

int main() {
    FILE *fp = NULL;
    fp = fopen("main.c", "r");
    if (!fp) return;
    defer(fclose, 1, fp);

    int *p = malloc(sizeof(*p));
    if (!p) return;
    defer(free, 1, p);

    defer(bar, 2, 13, "hello");
    return 0;
}

从这里我们可以看到defer的用法，但这不是重点，重点是实现。

有了上面的一些设计思路的阐述，下面的代码也就不难理解了。核心是defer.c。
/* defer.h */
typedef void (*defer_func)();

struct zero_params_func_ctx {
    defer_func df;
};

struct one_params_func_ctx {
    defer_func df;
    void *p1;
};

struct two_params_func_ctx {
    defer_func df;
    void *p1;
    void *p2;
};

struct defer_func_ctx {
    int params_count;
    union {
        struct zero_params_func_ctx zp;
        struct one_params_func_ctx op;
        struct two_params_func_ctx tp;
    } ctx;
};

void stack_push(struct defer_func_ctx *ctx);
struct defer_func_ctx* stack_pop();
int stack_top();

/* defer.c */
struct defer_func_ctx ctx_stack[10];
int top_of_stack = 0; /* stack top from 1 to 10 */

void stack_push(struct defer_func_ctx *ctx) {
    if (top_of_stack >= 10) {
        return;
    }

    ctx_stack[top_of_stack] = *ctx;
    top_of_stack++;
}

struct defer_func_ctx* stack_pop() {
    if (top_of_stack == 0) {
        return NULL;
    }

    top_of_stack–;
    return &ctx_stack[top_of_stack];
}

int stack_top() {
    return top_of_stack;
}

void defer(defer_func fp, int arg_count, …) {
    va_list ap;
    va_start(ap, arg_count);

    struct defer_func_ctx ctx;
    memset(&ctx, 0, sizeof(ctx));
    ctx.params_count = arg_count;

    if (arg_count == 0) {
        ctx.ctx.zp.df = fp;

    } else if (arg_count == 1) {
        ctx.ctx.op.df = fp;
        ctx.ctx.op.p1 = va_arg(ap, void*);

    } else if (arg_count == 2) {
        ctx.ctx.tp.df = fp;
        ctx.ctx.tp.p1 = va_arg(ap, void*);
        ctx.ctx.tp.p2 = va_arg(ap, void*);
        ctx.ctx.tp.df(ctx.ctx.tp.p1, ctx.ctx.tp.p2);
    }

    va_end(ap);
    stack_push(&ctx);
}

多个defer的FIFO调用顺序用一个固定大小的stack来实现。这里只是为了演示，所以stack实现的简单和固定些。

组装后的函数在funcexit.c中执行：

extern struct defer_func_ctx ctx_stack[10];

__attribute__((no_instrument_function))
void __cyg_profile_func_exit(void *this_fn, void *call_site) {
    struct defer_func_ctx *ctx = NULL;

    while ((ctx = stack_pop()) != NULL) {
        if (ctx->params_count == 0) {
            ctx->ctx.zp.df();
        } else if (ctx->params_count == 1) {
            ctx->ctx.op.df(ctx->ctx.op.p1);
        } else if (ctx->params_count == 2) {
            ctx->ctx.tp.df(ctx->ctx.tp.p1, ctx->ctx.tp.p2);
        }
    }
}

最后我们将defer.c、funcexit.c编译成一个.so文件：

gcc -g -fPIC -shared -o libcdefer.so funcexit.c defer.c

而编译main.c的方法如下：

gcc -g main.c -o main -finstrument-functions -I ../lib -L ../lib -lcdefer

一切OK后，先将libcdefer.so放在main同级目录下，执行main即可。

$> ./main
a = [13], s = [hello]

具体代码已经传至这里(trunk/cdefer)，需要的童鞋可自行下载。