C 语言中的面向切面编程(AOP)

[monkeyNik]

概念

首先给出一段由 ChatGPT 给出的简短的 AOP 概念：

AOP 是一种编程方法，用来将在程序中多处重复出现的代码（比如日志、权限控制）从主要业务逻辑中抽取出来，提高代码的模块化和可维护性。

抽取后的代码会在原始的业务逻辑代码中特定的位置执行，这些位置由切点（ Pointcut ）定义。通常会在方法执行前、执行后、抛出异常时等特定点执行抽取出的代码，这些点被称为连接点（ Join Point ）。

概述

在 C 语言中，编译器所提供的编译期和执行期的能力相较于 java 或者其他语言来说会弱一些，这也许就是可能很少听到在 C 语言中搞面向切面编程的原因之一吧。

从上面的概念上来看，AOP 一般是在一些函数（或类方法）执行前后做一些额外处理，例如调用前增加一些权限控制，调用后增加一些日志记录。从这些行为上来说，任何语言其实都可以做到。我们可以简单的在一个函数的开始加一段逻辑或调用某个函数来实现权限验证，在函数返回前调用某个函数添加日志等等。类似如下代码：

void foo(void)
{
  if (!verify_identity())
    return;

  //...
  
  log("end");
}

但很显然，这么做会在程序的很多个函数中添加很多重复的代码（例如本例的verify_identity和log），以至于代码变得比较臃肿。

那么有没有什么办法来瘦身呢？

这就是 AOP 擅长的领域了。

写在示例之前

C 语言编译器没有提供很完整的 AOP 支持，因此我们需要自行手动实现，或者使用一些现有的库来实现。

本文将使用开源 C 语言库 Melon 的函数模板来实现上面的效果。

在 Melon 提供的函数模板组件中，实现了若干宏函数，这些宏函数都是用来定义不同类型的函数的。这些用宏来定义的函数和我们原生 C 语言中的函数的区别，简单来说就是，在我们实际要执行的函数逻辑外，再封装一个函数，这个函数会在我们指定的函数逻辑开始前和结束后调用一个回调函数（即函数的入口回调函数和出口回调函数）。

基于函数模板的这一特性，Melon 中实现了一个 span 组件，用来度量使用函数模板定义的函数的时间开销。

但如果事情仅限于此，那么这种 AOP 很显然能做到的事情也基本仅限于此了。

因此，Melon 支持了 c99 ，并利用 c99 提供的宏特性，实现了将函数模板定义的函数的实参以可变参数的形式传递到入口和出口回调函数中。这就意味着，入口和出口回调函数可以访问函数的参数，并对参数的内容作出修改（主要针对指针指向的内存中的数据）。

这样，就给我们在回调函数中提供了更多的可操作空间。我们可以针对不同的函数，修改其参数值，从而来影响后续函数调用中的执行逻辑。例如前面的权限验证，我们可以将其大致简化为如下形式：

void entry_callback(char *file, char *func, int line, ...)
{
  va_list args;
  va_start(args, line);
  int *a = (int *)va_arg(args, int *);
  va_end(args);
  if (!verify_identity())
    *a = 0;
}

void exit_callback(char *file, char *func, int line, ...)
{
  va_list args;
  va_start(args, line);
  int *a = (int *)va_arg(args, int *);
  va_end(args);
  log("%d\n", *a);
}

void foo(int *a)
{
  if (!*a)
    return;

  //...
}

int bar(int *d, int e)
{
  if (!*d)
    return -1;

  //...
  return 0;
}

这里的代码只是一个示意，后面会给出一个实际可用的示例。

我们可以随意增加函数，这些函数都会利用同一对入口和出口函数来实现身份验证。

示例

下面就给出一个可用的使用函数模板实现 AOP 的 C 语言代码。

//a.c

#include "mln_func.h"
#include <stdio.h>
#include <string.h>
#include <stdarg.h>

MLN_FUNC_VOID(static, void, foo, (int *a, int b), (a, b), {
    printf("in %s: %d\n", __FUNCTION__, *a);
    *a += b;
})

MLN_FUNC(static, int, bar, (void), (), {
    printf("%s\n", __FUNCTION__);
    return 0;
})

static void my_entry(const char *file, const char *func, int line, ...)
{
    if (strcmp(func, "foo"))
        return;

    va_list args;
    va_start(args, line);
    int *a = (int *)va_arg(args, int *);
    va_end(args);

    printf("entry %s %s %d %d\n", file, func, line, *a);
    ++(*a);
}

static void my_exit(const char *file, const char *func, int line, ...)
{
    if (strcmp(func, "foo"))
        return;

    va_list args;
    va_start(args, line);
    int *a = (int *)va_arg(args, int *);
    va_end(args);

    printf("exit %s %s %d %d\n", file, func, line, *a);
}

int main(void)
{
    int a = 1;

    mln_func_entry_callback_set(my_entry);
    mln_func_exit_callback_set(my_exit);

    foo(&a, 2);
    return bar();
}

这段函数中，我们使用MLN_FUNC和MLN_FUNC_VOID来定义了两个函数，即foo和bar。两个函数的逻辑很简单，就是 printf 输出当前函数名以及参数值（如果有参数的话）。同时，我们也使用了mln_func_entry_callback_set和mln_func_exit_callback_set定义了两个全局回调函数，用来在函数调用开始和结束时调用。

我们可以看到，回调函数中使用strcmp对进入回调的函数做了过滤，仅对foo函数做额外处理。在入口回调中输出函数信息及第一个参数的值，随后修改参数指针指向的内存中的值。在出口回调中输出函数信息和参数值。

我们来编译一下（我们假定这个代码文件名为a.c）：

cc -o a a.c -I /usr/local/melon/include/ -L /usr/local/melon/lib/ -lmelon -std=c99 -DMLN_C99 -DMLN_FUNC_FLAG

这里：

• /usr/local/melon是 Melon 库的默认安装路径。
• -std=c99是启用 c99 。
• -DMLN_C99是定义一个名为MLN_C99的宏，这个宏用来启用函数模板组件中 C99 下才有的特性。
• -DMLN_FUNC_FLAG用来定义一个名为MLN_FUNC_FLAG的宏，这个宏用来启用函数模板功能。是的，如果没有这个宏，上面的那些使用MLN_FUNC定义的函数就是普通的 C 语言函数，也不会触发入口和出口回调函数的调用。

执行一下看看效果：

entry a.c foo 6 1
in __mln_func_foo: 2
exit a.c foo 6 4
__mln_func_bar

可以看到：

• 入口回调函数中，foo 的第一个参数指向的内存中的值为1。
• 进入foo的实际函数逻辑中，printf 输出当前的函数名为__mln_func_foo，以及此时看到的第一个参数的值为2，不再是1了，因为在入口回调函数中被修改了。__mln_func_foo这个函数执行的才是我们定义的逻辑，而foo是对__mln_func_foo的一个封装。
• 出口回调函数中，我们看到第一个参数的值变为了4，因为它在我们给出的函数逻辑中做了修改。
• 最后输出的是bar的实际执行逻辑所在的函数名，与foo的形式一致。

最后，我们去掉MLN_FUNC_FLAG这个宏再次编译一次：

cc -o a a.c -I /usr/local/melon/include/ -L /usr/local/melon/lib/ -lmelon -std=c99 -DMLN_C99

然后执行一下看看输出结果：

in foo: 1
bar

可以看得出，此时foo和bar不再是封装函数，而是我们定义的函数逻辑的函数名，即普通的 C 语言函数。

读到这里的都是真爱，感谢阅读！

[andytao]

加把劲，再深入一点。。。

[monkeyNik]

@andytao 又更新了一下，支持过滤了，入口回调的返回值变为 int ，返回小于 0 的值时，实际功能函数（以__mln_func_为前缀的那个函数）不会被调用，函数直接返回，除了 void 类型返回值的函数以外，其他的都返回 MLN_FUNC_ERROR

[zoumouse]

可以考虑用 LLVM 扩展

[chisato]

__attribute__((constructor))
__attribute__((destructor))

[monkeyNik]

@chisato 这确实可以起到类似效果，但是你无法很容易地从回调函数中获取被调用的函数，并对这个被调用函数进行拦截。