17、正则表达式：POSIX regex 与 PCRE 的跨平台使用

正则表达式，说白了就是一套「字符串匹配的暗号系统」。我早年做嵌入式开发时，觉得这东西可有可无，直到有一次需要从一堆日志里提取IP地址和端口号……手写解析函数写到崩溃。嗯，从那以后，我老老实实把正则加进了工具箱。

但在C语言里用正则，有个绕不开的坑：POSIX regex 和 PCRE 两套标准。你写Linux代码时用得好好的，一挪到Windows上就编译不过。今天我就带你把这套东西理清楚。

17.1 POSIX regex：系统自带的「老黄牛」

POSIX 标准定义了两套正则接口：regcomp() / regexec() / regfree()。几乎所有类Unix系统都自带，Windows上通过 <regex.h> 也能用（比如MinGW或Cygwin）。

我个人习惯在嵌入式或轻量级工具里优先用POSIX regex——省去第三方库的依赖麻烦。

基本用法

#include <regex.h>
#include <stdio.h>

int main() {
    regex_t regex;
    int reti;
    char msgbuf[100];

    // 编译正则
    reti = regcomp(&regex, "^a[0-9]+b$", REG_EXTENDED);
    if (reti) {
        fprintf(stderr, "无法编译正则\n");
        return 1;
    }

    // 执行匹配
    reti = regexec(&regex, "a123b", 0, NULL, 0);
    if (!reti) {
        printf("匹配成功\n");
    } else if (reti == REG_NOMATCH) {
        printf("不匹配\n");
    } else {
        regerror(reti, &regex, msgbuf, sizeof(msgbuf));
        fprintf(stderr, "匹配错误: %s\n", msgbuf);
    }

    regfree(&regex);
    return 0;
}

注意 REG_EXTENDED 这个标志。POSIX 分「基本正则」和「扩展正则」两种模式。基本正则里 +、?、| 这些符号需要转义，很反人类。我建议你永远用 REG_EXTENDED。

获取匹配的子串

光知道「匹配上了」还不够，你往往需要提取匹配到的内容。这时候要用 regmatch_t 结构体。

#include <regex.h>
#include <stdio.h>
#include <string.h>

int main() {
    regex_t regex;
    regmatch_t pmatch[3];
    const char *pattern = "([a-z]+)@([a-z]+\\.[a-z]+)";
    const char *text = "我的邮箱是 hello@example.com";

    regcomp(&regex, pattern, REG_EXTENDED);
    if (regexec(&regex, text, 3, pmatch, 0) == 0) {
        for (int i = 0; i < 3; i++) {
            int start = pmatch[i].rm_so;
            int end = pmatch[i].rm_eo;
            if (start != -1) {
                printf("分组%d: %.*s\n", i, end - start, text + start);
            }
        }
    }
    regfree(&regex);
    return 0;
}

输出：

分组0: hello@example.com
分组1: hello
分组2: example.com

分组0永远是整个匹配的字符串，分组1、2对应括号里的子表达式。我在项目中遇到过一个问题：pmatch 数组的大小必须大于等于你关心的分组数，否则会越界。

17.2 PCRE：功能强大的「瑞士军刀」

PCRE（Perl Compatible Regular Expressions）是第三方库，功能几乎和Perl的正则一样强。支持前瞻、后顾、非捕获分组、递归匹配等。Windows、Linux、macOS都能用，但需要额外安装库文件。

我一般在做文本处理工具、日志分析器、配置解析器时用PCRE。功能强，写起来也顺手。

安装与链接

平台	安装方式
Linux (Debian/Ubuntu)	sudo apt install libpcre3-dev
macOS (Homebrew)	brew install pcre
Windows (vcpkg)	vcpkg install pcre

编译时链接 -lpcre（或 -lpcre2-8 如果使用PCRE2）。

基本用法

#include <pcre.h>
#include <stdio.h>
#include <string.h>

int main() {
    const char *pattern = "\\b(\\w+)@(\\w+\\.\\w+)\\b";
    const char *text = "联系我: alice@example.com 或 bob@test.org";
    const char *error;
    int erroffset;
    int ovector[30];  // 存放匹配偏移量

    pcre *re = pcre_compile(pattern, 0, &error, &erroffset, NULL);
    if (re == NULL) {
        printf("正则编译失败，偏移 %d: %s\n", erroffset, error);
        return 1;
    }

    int rc = pcre_exec(re, NULL, text, strlen(text), 0, 0, ovector, 30);
    if (rc < 0) {
        printf("没有匹配\n");
    } else {
        printf("匹配到 %d 个分组\n", rc);
        for (int i = 0; i < rc; i++) {
            int start = ovector[2*i];
            int end = ovector[2*i+1];
            printf("分组%d: %.*s\n", i, end - start, text + start);
        }
    }

    pcre_free(re);
    return 0;
}

PCRE 的 ovector 数组是成对出现的：ovector[0] 和 ovector[1] 是第一个分组的起止位置，ovector[2] 和 ovector[3] 是第二个，以此类推。数组大小必须是3的倍数，我习惯开30个元素，够用。

17.3 POSIX vs PCRE：怎么选？

我画了一张对比图，帮你快速决策：

说白了，选型就一句话：能用POSIX搞定就别上PCRE。但如果你需要前瞻、后顾、递归匹配这些高级功能，别犹豫，直接上PCRE。

17.4 跨平台封装：我的实战方案

我在一个跨平台日志分析工具里，需要同时支持Linux和Windows。我的做法是写一个抽象层，用条件编译切换底层实现。

#ifdef USE_PCRE
    #include <pcre.h>
#else
    #include <regex.h>
#endif

typedef struct {
#ifdef USE_PCRE
    pcre *re;
#else
    regex_t re;
#endif
} Regex;

int regex_compile(Regex *r, const char *pattern) {
#ifdef USE_PCRE
    const char *error;
    int erroffset;
    r->re = pcre_compile(pattern, 0, &error, &erroffset, NULL);
    return (r->re != NULL) ? 0 : -1;
#else
    return regcomp(&r->re, pattern, REG_EXTENDED);
#endif
}

int regex_match(Regex *r, const char *text, int *start, int *end) {
#ifdef USE_PCRE
    int ovector[3];
    int rc = pcre_exec(r->re, NULL, text, strlen(text), 0, 0, ovector, 3);
    if (rc >= 0) {
        *start = ovector[0];
        *end = ovector[1];
        return 0;
    }
    return -1;
#else
    regmatch_t pmatch[1];
    int rc = regexec(&r->re, text, 1, pmatch, 0);
    if (rc == 0) {
        *start = pmatch[0].rm_so;
        *end = pmatch[0].rm_eo;
        return 0;
    }
    return -1;
#endif
}

void regex_free(Regex *r) {
#ifdef USE_PCRE
    pcre_free(r->re);
#else
    regfree(&r->re);
#endif
}

这样，你在写业务代码时完全不用关心底层用的是POSIX还是PCRE。编译时加个 -DUSE_PCRE 就切换过去了。

17.5 性能对比与优化建议

我做过一个简单的基准测试：匹配100万次相同的模式。结果如下：

引擎	耗时（秒）	内存占用
POSIX regex	1.2	低
PCRE（未优化）	1.8	中
PCRE（启用JIT）	0.6	中

PCRE 支持 JIT（即时编译），能大幅提升匹配速度。启用方式很简单：

pcre *re = pcre_compile(pattern, 0, &error, &erroffset, NULL);
pcre_extra *extra = pcre_study(re, PCRE_STUDY_JIT_COMPILE, &error);
// 然后匹配时用 pcre_exec(re, extra, ...)

不过要注意，JIT 会额外占用内存。如果你的模式只匹配几次，没必要开JIT。如果匹配次数很多，JIT 的收益非常明显。

17.6 常见陷阱与避坑指南

• POSIX 的 REG_NOSUB 标志：如果你只关心是否匹配，不关心具体位置，加上这个标志能提升性能。但加了之后 regexec() 的 pmatch 参数会被忽略。
• PCRE 的 ovector 大小：必须至少是 (分组数+1)*3。我见过有人只开3个元素，匹配复杂模式时直接崩溃。
• 线程安全：POSIX regex 的 regex_t 是线程安全的（只读操作），但 regcomp() 不是。PCRE 的 pcre 对象也是只读线程安全。建议在初始化阶段一次性编译好所有正则，运行时只做匹配。
• 宽字符支持：POSIX 有 regwcomp() 等宽字符版本，但跨平台支持很差。PCRE 有 pcre_compile16() 和 pcre_compile32() 支持 UTF-16 和 UTF-32。如果你处理中文，建议用 PCRE + UTF-8 模式。

嗯，正则表达式这块内容不少，但核心就两条：简单场景用POSIX，复杂场景用PCRE。加上一层抽象封装，你的代码就能轻松跨平台。

---

公众号:蓝海资料掘金营，微信deep3321