C语言正则表达式子组捕获不符合预期，如何捕获全部目标整数？

为什么只捕获到最后一个整数？ #

你写的正则表达式里，每个( ([1-9][0-9]*))*都是重复的捕获组。正则引擎的规则是：当一个捕获组被*（或+、?）重复匹配时，每次新的匹配都会覆盖该捕获组之前存储的内容。哪怕你写了11个这样的重复组，每个组最终只会保留它最后一次匹配到的结果——你的示例字符串里每个组最后一次匹配的都是11，所以最终只能拿到最后一个整数。

举个简单例子：( ([0-9]+))*匹配hl 1 2 3时，捕获组1的内容会依次变成 1、 2、 3，最终只留下 3。你写的多个重复组本质是一样的逻辑，每个组都重复匹配直到最后一个整数，结果全部覆盖成最后一个值。

如何捕获所有11个整数？ #

方法1：使用标准POSIX正则（适配C标准库） #

C标准库的regexec属于POSIX正则实现，它不支持获取捕获组的所有重复匹配结果，只能拿到每个捕获组的最后一次匹配值。因此需要分两步处理：

1. 先用简洁的正则验证字符串格式是否符合要求；
2. 在验证通过的字符串中，逐个提取所有整数。

示例代码：

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

#define HL_VALIDATE_REGEX "^hl( [1-9][0-9]*){1,11}$"
#define HL_EXTRACT_REGEX "[1-9][0-9]*"

int main() {
    char *sampleValue = "hl 1 2 3 4 5 6 7 8 9 10 11";
    regex_t validate_regex, extract_regex;
    regmatch_t match;
    int ret;

    // 验证字符串格式
    ret = regcomp(&validate_regex, HL_VALIDATE_REGEX, REG_EXTENDED);
    if (ret != 0) {
        fprintf(stderr, "正则编译失败\n");
        return 1;
    }
    ret = regexec(&validate_regex, sampleValue, 0, NULL, 0);
    if (ret != 0) {
        fprintf(stderr, "字符串格式不符合要求\n");
        regfree(&validate_regex);
        return 1;
    }
    regfree(&validate_regex);

    // 逐个提取整数
    ret = regcomp(&extract_regex, HL_EXTRACT_REGEX, REG_EXTENDED);
    if (ret != 0) {
        fprintf(stderr, "正则编译失败\n");
        return 1;
    }

    char *pos = sampleValue;
    int count = 0;
    while (regexec(&extract_regex, pos, 1, &match, 0) == 0 && count < 11) {
        char num_str[12]; // 预留11位整数加终止符的空间
        strncpy(num_str, pos + match.rm_so, match.rm_eo - match.rm_so);
        num_str[match.rm_eo - match.rm_so] = '\0';
        printf("捕获到整数：%s\n", num_str);
        count++;
        pos += match.rm_eo; // 移动指针到下一个匹配起始位置
    }
    regfree(&extract_regex);

    return 0;
}

方法2：使用支持捕获组迭代的正则库（如PCRE） #

如果项目允许引入第三方库，PCRE（Perl兼容正则表达式）支持获取捕获组的所有重复匹配结果，也可以通过全局匹配模式逐个提取整数。

简化示例：

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

#define HL_EXTRACT_REGEX "[1-9][0-9]*"

int main() {
    char *sampleValue = "hl 1 2 3 4 5 6 7 8 9 10 11";
    const char *error;
    int erroffset;
    pcre *extract_re = pcre_compile(HL_EXTRACT_REGEX, 0, &error, &erroffset, NULL);
    if (!extract_re) {
        fprintf(stderr, "正则编译失败：%s\n", error);
        return 1;
    }

    int ovector[30]; // 存储匹配位置的数组，足够容纳11个整数的位置信息
    int pos = 0;
    int count = 0;
    int rc;

    while ((rc = pcre_exec(extract_re, NULL, sampleValue, strlen(sampleValue), pos, 0, ovector, 30)) >= 0 && count < 11) {
        char num_str[12];
        strncpy(num_str, sampleValue + ovector[0], ovector[1] - ovector[0]);
        num_str[ovector[1] - ovector[0]] = '\0';
        printf("捕获到整数：%s\n", num_str);
        pos = ovector[1];
        count++;
    }

    pcre_free(extract_re);
    return 0;
}

补充：简化初始正则表达式 #

你最初写的正则重复了11次相同结构，完全可以简化为^hl( [1-9][0-9]*){1,11}$，其中{1,11}表示匹配1到11次“空格+整数”的结构，既简洁又能准确限制整数数量。

内容的提问来源于stack exchange，提问作者Dennis