POSIX正規表現 regex.h

• 使用方法
• POSIX正規表現のいくつかの例
• コード例と若干の解説
• 実践的なコード例

使用方法

regex.hでの正規表現の基本的な使用方法を簡単に述べると、次のようになります。

1. regcomp()で正規表現パターンをコンパイル
2. regexec()で実行
3. regfree()で正規表現パターンバッファを解放

正規表現用の関数

regcomp()

正規表現を使用した検索を行うには、事前に正規表現パターンをコンパイルしておく必要があります。正規表現パターンをコンパイルするには、関数regcompを使用します。

引数について

1. regex_tはregex.hの関数を使用するためにtypedefされた型で、おそらく構造体として宣言されていると思いますが、その内容を気にする必要はありません(正規表現ライブラリの実装に興味がある場合は別として)。regex_t型のオブジェクトを作成し、そのアドレスを渡すのが一般的な使い方となります。
2. 正規表現パターンの文字列の先頭へのポインタを渡します。
3. REG_EXTENDED、REG_ICASE、REG_NOSUB、REG_NEWLINEのbitwise-orで指定されるフラグを渡します。古いプログラムとの互換性以外には基本正規表現を使用するメリットはないと思われるので、このページでは、常にREG_EXTENDEDフラグを指定するものとします。他のフラグの詳細については後述します。

regexec()

実際のパターンマッチングは、関数regcompによってコンパイルされたパターンバッファを関数regexecに渡すことで行います。この関数の動作は、コンパイル時に関数regcompに対して指定したフラグの影響を受けます。

引数について

1. regcomp()によってコンパイルされたパターンバッファを指すポインタを渡す必要があります。
2. 正規表現パターンによる検索を行う対象の文字列の先頭へのポインタを渡します。
3. 位置情報を格納するためのバッファの大きさを指定します。
4. regmatch_t型のオブジェクトを適切に配置可能なバッファの先頭へのポインタを渡します。各オブジェクトには、位置情報が格納されます。なお、3番目の引数とともに、この引数が意味を持つかどうかはregcomp()でパターンをコンパイルする際のREG_NOSUBフラグに左右されます。詳細については後述します。
5. REG_NOTBOL、REG_NOTEOLのbitwise-orで指定されるフラグを渡します。詳細は後述します。

regerror()

引数について

1. regcomp()またはregexec()の返却値をそのまま渡します。
2. 正規表現パターンバッファへのポインタを渡します。
3. エラー情報を格納するためのバッファへのポインタを渡します。このバッファは呼び出し側で予め確保しておきます。
4. エラー情報を格納するためのバッファに格納できる最大の文字数を渡します。

regfree()

正規表現パターンをコンパイルするための関数regcompは、関数内でメモリを確保します。そのため、不要になった正規表現パターンバッファは開放しておく必要があります。

POSIX正規表現のいくつかの例

詳細なマニュアルはManpage of REGEXを見てください。ここでは、使用頻度の高そうな一部の例のみ解説します。なお、以下の記述は拡張正規表現を前提としています。

繰り返し

ブラケット表現

文字クラス

コード例と若干の解説

regerror()を用いたエラーメッセージ文字列の取得

まず、関数regerrorを用いてエラーメッセージ文字列を得る例を示します。パターンバッファのコンパイル結果は役に立つ情報なので、実際のプログラムではregcomp()の返却値を取得するようにしておいた方が良いでしょう。

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

int main(void)
{
    regex_t reg;
    regmatch_t match;
    char errbuf[100];
    char comment[] = "abcdefghij";

    printf("元の文字列: %s\n\n", comment);

    regerror(regcomp(&reg, "[ijk", REG_EXTENDED), &reg, errbuf, sizeof errbuf);
    printf("regcompエラーコード: %s\n", errbuf);
    regerror(regcomp(&reg, "ijk", REG_EXTENDED), &reg, errbuf, sizeof errbuf);
    printf("regcompエラーコード: %s\n", errbuf);

    regerror(regexec(&reg, comment, 1, &match, 0), &reg, errbuf, sizeof errbuf);
    printf("regexecエラーコード: %s\n", errbuf);

    regfree(&reg);
    return 0;
}

実行結果は次のようになります。

元の文字列: abcdefghij

regcompエラーコード: Unmatched [ or [^
regcompエラーコード: Success
regexecエラーコード: No match

パターンマッチングと位置情報

文字列に正規表現パターンにマッチする部分があるとき、それがどの部分なのかがわかると便利です。regexec()の3番目と4番目の引数はその目的で使用します。4番目の引数は、regmatch_t型オブジェクトへのポインタです。regmatch_tは構造体で、次のようにtypedefされています。

typedef struct
{
    regoff_t rm_so;
    regoff_t rm_eo;
}regmatch_t;

位置情報を用いたコード例

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

void put_n_char(const char *s, regoff_t so, regoff_t eo)
{
    const char * const ep = s + eo;

    for(s += so; s != ep; s++) putchar(*s);
}

int main(void)
{
    regex_t reg;
    const char *pattern = "h(ttp:(//))([[:alnum:]./]+)";

    regmatch_t match[5];
    int match_elems = sizeof match / sizeof match[0];

    char *s[] = {
        "http://www.example.com",
        "123http://www.google.com/",
    };
    int s_elems = sizeof s / sizeof s[0];

    int i, j;

    regcomp(&reg, pattern, REG_EXTENDED);

    for(i = 0; i < s_elems; i++) {
        if(regexec(&reg, s[i], match_elems, match, 0) != REG_NOMATCH) {

            for(j = 0; j < match_elems; j++) {
                // 注: 実装によっては regoff_t は単純な int でない可能性がある
                printf("%2d, %2d: ", match[j].rm_so, match[j].rm_eo);
                if(match[j].rm_so >= 0)
                    put_n_char(s[i], match[j].rm_so, match[j].rm_eo);
                puts("");
            }
        }
        puts("");
    }

    regfree(&reg);

    return 0;
}

 0, 22: http://www.example.com
 1,  7: ttp://
 5,  7: //
 7, 22: www.example.com
-1, -1:

 3, 25: http://www.google.com/
 4, 10: ttp://
 8, 10: //
10, 25: www.google.com/
-1, -1:

単純なパターンマッチング(REG_NOSUBコンパイルフラグ)

文字列がパターンを含んでいるかどうかさえわかれば良いような場合は、regcomp()による正規表現パターンのコンパイル時にREG_NOSUBコンパイルフラグを指定しておけば、regmatch_t型のオブジェクトを作る必要がなくなるので、ほんのわずかですがコードを簡略化できます。

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

int main(void)
{
    char *s[] = { "abcdefgeh", "ijklmnopq", };
    int s_size = sizeof s / sizeof s[0];
    int i;

    char *pattern = "def";
    regex_t reg;

    regcomp(&reg, pattern, REG_EXTENDED|REG_NOSUB);

    for(i = 0; i < s_size; i++, puts("")) {
        printf("検索対象文字列: %s, パターン: %s, 結果: ", s[i], pattern);

        if(regexec(&reg, s[i], 0, NULL, 0) != REG_NOMATCH) printf("Matched!");
        else printf("No Match!");
    }

    return 0;
}

この例では、regexec()の3番目と4番目の引数が意味を持たなくなります。文字列がパターンを含むかどうかは、regexec()の返却値によって知ることができます。

検索対象文字列: abcdefgeh, パターン: def, 結果: Matched!
検索対象文字列: ijklmnopq, パターン: def, 結果: No Match!

大文字と小文字を区別しないパターンマッチング(REG_ICASEコンパイルフラグ)

regex.hでの改行の扱いについて(REG_NEWLINEコンパイルフラグ、REG_NOTBOL/REG_NOTEOL)

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

int main(void)
{
    char *s[] = { "opq\nabcdefgeh", "ijklmnopq", "ijklmnopq\n", };
    int s_size = sizeof s / sizeof s[0];
    int i;

    char *pattern = "opq$";
    regex_t reg;

    regcomp(&reg, pattern, REG_EXTENDED|REG_NOSUB);

    for(i = 0; i < s_size; i++, puts("")) {
        printf("検索対象文字列: %s, パターン: %s, 結果: ", s[i], pattern);

        if(regexec(&reg, s[i], 0, NULL, 0) != REG_NOMATCH) printf("Matched!");
        else printf("No Match!");
    }

    return 0;
}

検索対象文字列: opq
abcdefgeh, パターン: opq$, 結果: No Match!
検索対象文字列: ijklmnopq, パターン: opq$, 結果: Matched!
検索対象文字列: ijklmnopq
, パターン: opq$, 結果: No Match!

REG_NEWLINEコンパイルフラグ

regcomp()のコンパイルフラグに、

    regcomp(&reg, pattern, REG_EXTENDED|REG_NOSUB|REG_NEWLINE);

のようにREG_NEWLINEを追加すると、実行結果は次のようになります。

検索対象文字列: opq
abcdefgeh, パターン: opq$, 結果: Matched!
検索対象文字列: ijklmnopq, パターン: opq$, 結果: Matched!
検索対象文字列: ijklmnopq
, パターン: opq$, 結果: Matched!

        if(regexec(&reg, s[i], 0, NULL, REG_NOTEOL) != REG_NOMATCH) printf("Matched!");

のようにREG_NOTEOLを追加すると、文字列の末尾が行末として扱われなくなります。

検索対象文字列: opq
abcdefgeh, パターン: opq$, 結果: Matched!
検索対象文字列: ijklmnopq, パターン: opq$, 結果: No Match!
検索対象文字列: ijklmnopq
, パターン: opq$, 結果: Matched!

実践的なコード例

正規表現パターンにマッチする部分文字列の数を数える

#include <regex.h>


// REG_NOSUB フラグを指定せずにコンパイルされた regex パターンバッファを渡すこと
size_t regmatch_count(const char *s, const regex_t *reg)
{
    size_t match_count = 0;
    regmatch_t pmatch;

    if(!reg) return 0;

    for(/* */; regexec(reg, s, 1, &pmatch, 0) != REG_NOMATCH; s += pmatch.rm_eo)
        match_count++;

    return match_count;
}

正規表現パターンにマッチした部分文字列を置換する

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


// regexec()の実行により位置情報格納済みのregmatch_t型オブジェクトを指すポインタを渡すこと
// 置換後に部分文字列が長くなる場合、whole_stringは動的に確保された領域を指している必要がある
char *regmatch_replace(char *whole_string, const regmatch_t *match, const char *replaced)
{
    const size_t src_len = (size_t)(match->rm_eo - match->rm_so);
    const size_t dst_len = strlen(replaced);

    char *rm_start = whole_string + match->rm_so;
    char *rm_end = whole_string + match->rm_eo;

    if(src_len < dst_len) {
        whole_string = realloc(whole_string, strlen(whole_string) + (dst_len - src_len) + 1);
        if(!whole_string) return NULL;
    }

    memmove(rm_start + dst_len, rm_end, strlen(rm_end) + 1);
    strncpy(rm_start, replaced, dst_len);

    return whole_string;
}

最終更新日 2009年6月8日