【C言語】 関数マクロの作り方と使い方｜引数付き・多文マクロの安全な書き方

C言語では、プリプロセッサの機能として関数マクロを使うことで、コードを簡潔にしたり、処理を共通化したりできます。

一方で、誤った書き方をするとバグや可読性の低下につながります。

本記事では、関数マクロの基本から、多文マクロの安全な書き方、インライン関数との使い分けまで、実践で役立つ観点から詳しく解説します。

関数マクロとは？基本概念と関数との違い

関数マクロの概要と展開の仕組み

関数マクロとは、C言語のプリプロセッサ機能である#defineを使って、関数のように引数を取るマクロのことです。

コンパイル前のソースコード置換として働き、実行時の関数呼び出しではありません。

関数マクロは、次のような書き方をします。

// 2つの値の最大値を返す関数マクロの例
#define MAX(a, b)  ((a) > (b) ? (a) : (b))

このマクロを

int x = 5;
int y = 10;
int m = MAX(x, y);

のように使用した場合、プリプロセッサによって次のようにソースコードレベルで置換されます。

int x = 5;
int y = 10;
int m = ((x) > (y) ? (x) : (y));

ここで重要なのは、コンパイラに渡る時点では、もはやMAXという名前は存在していないという点です。

この仕組みが、後述する注意点や落とし穴の原因になります。

C言語の関数との違い

通常のC言語の関数と関数マクロには、次のような違いがあります。

代表的な違いを表にまとめます。

関数マクロは型が存在しないため、どんな引数でも書けてしまいますが、その分コンパイラの型チェックによる安全性が失われます。

関数マクロを使うメリットとデメリット

関数マクロには、次のようなメリットがあります。

• 実行時オーバーヘッドがほぼゼロで、インライン展開される
• 型に依存せず、intでもdoubleでも使い回せる汎用コードを書きやすい
• 条件コンパイルと組み合わせることで、ロギングやトレースなどを柔軟に制御できる

一方で、デメリットも多く存在します。

• 引数が何回評価されるかが分かりづらく、副作用持ちの式が危険
• デバッガでステップ実行すると、展開後の複雑な式として見え、追いづらい
• 型安全でないため、意図しない型の値を渡してもコンパイルエラーにならない
• グローバルな置換であるため、名前の衝突や予期しない展開が起こり得る

そのため、「どんなときでも関数マクロが便利」ではなく、「必要な局面を見極めて慎重に使う」ことが重要になります。

関数マクロの作り方と使い方

引数付き関数マクロの基本構文と記述例

引数付き関数マクロの基本構文は、次のようになります。

#define マクロ名(引数1, 引数2, ...)   置換されるコード

注意点として、#defineとマクロ名の間には空白を入れますが、マクロ名と括弧の間には空白を入れません。

空白を入れると「引数なしマクロ」と解釈されてしまいます。

単純な例: 2乗を求めるマクロ

#include <stdio.h>

// 引数xの2乗を計算するマクロ
#define SQUARE(x)  ((x) * (x))

int main(void) {
    int a = 3;
    int b = SQUARE(a + 1);   // (a + 1) * (a + 1) に展開される

    printf("a = %d\n", a);
    printf("SQUARE(a) = %d\n", SQUARE(a));
    printf("SQUARE(a + 1) = %d\n", b);

    return 0;
}

a = 3
SQUARE(a) = 9
SQUARE(a + 1) = 16

この例のように、単純な計算処理であれば、関数マクロを使うことでコードを簡潔に記述できます。

ただし、(x)や全体を括弧で囲んでいる点が安全なマクロの第一歩です。

これについては後ほど詳しく解説します。

引数評価に関する注意点

関数マクロの最も大きな落とし穴の1つが、引数が複数回評価されることです。

問題のある例を見てみます。

#include <stdio.h>

// よくある2乗マクロの例 (一見問題なさそうに見える)
#define SQUARE(x)  ((x) * (x))

int main(void) {
    int i = 3;

    // マクロ引数に副作用のある式を渡してしまう
    int r = SQUARE(i++);   // ((i++) * (i++)) に展開される

    printf("r = %d\n", r);
    printf("i = %d\n", i);

    return 0;
}

r = 12
i = 5

このコードでは、i++ が2回実行されることになり、予想と異なる結果になります。

通常の関数であれば、引数は1回だけ評価されるため、このような問題は起こりません。

そのため、副作用(インクリメント、代入、関数呼び出しなど)を含む式をマクロ引数に渡さないことが重要です。

どうしても必要な場合は、関数マクロではなく通常の関数やインライン関数の利用を検討すべきです。

マクロ引数に括弧を付ける理由と安全な書き方

安全な関数マクロを書くうえで、「引数にも展開結果にも括弧を徹底的に付ける」ことが非常に重要です。

例を見てみます。

#include <stdio.h>

// 悪い例: 括弧がないマクロ
#define MUL_BAD(a, b) a * b

// 良い例: 括弧を徹底したマクロ
#define MUL_GOOD(a, b)  ((a) * (b))

int main(void) {
    int x = 1;
    int y = 2;
    int z = 3;

    int r1 = MUL_BAD(x + y, z + 1);   // 実際の式は x + y * z + 1 になる
    int r2 = MUL_GOOD(x + y, z + 1);  // ((x + y) * (z + 1)) になる

    printf("MUL_BAD  = %d\n", r1);
    printf("MUL_GOOD = %d\n", r2);

    return 0;
}

MUL_BAD  = 6
MUL_GOOD = 8

同じ入力でも結果が変わってしまう様子が分かると思います。

これは、展開された式x + y * z + 1で、演算子の優先順位によりy * zが先に計算されてしまうためです。

安全なマクロを書くための基本ルールとして、次のように覚えておくとよいです。

• マクロ引数は(a)のように必ず括弧で囲む
• マクロ全体の展開結果も((a) + (b))のように括弧で囲む

この2点を守るだけでも、多くのバグを防ぐことができます。

多文マクロの安全な書き方

多文マクロ(複数文マクロ)とは何か

多文マクロ(複数文マクロ)とは、1つのマクロ展開で複数の文(ステートメント)を生成するマクロのことです。

ログ出力や、エラー処理など、一連の処理をまとめたい場合によく使われます。

例として、エラー時にメッセージを出力して終了する多文マクロを考えます。

// 悪い例: 多文マクロ (まだ安全な形にしていない)
#define DIE(msg) \
    fprintf(stderr, "Error: %s\n", msg); \
    exit(1)

このマクロを使うと、展開後に2行のコードになります。

単純に見えますが、if文との組み合わせなどで危険な副作用が出てきます。

次のセクションで詳しく見ていきます。

do { … } while(0)イディオムの意味と使い方

多文マクロを安全に使うための有名なテクニックがdo { ... } while(0)イディオムです。

これは、多文マクロを1つの文として扱えるようにするためのパターンです。

安全な多文マクロの書き方は、次のようになります。

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

// 安全な多文マクロの例
#define DIE(msg)                                      \
    do {                                              \
        fprintf(stderr, "Error: %s\n", (msg));        \
        exit(1);                                      \
    } while (0)

int main(void) {
    int x = 0;

    if (x == 0)
        DIE("x must not be zero");

    printf("この行は実行されません\n");
    return 0;
}

Error: x must not be zero

do { ... } while(0)で囲む理由は、次のような性質を持たせるためです。

• 呼び出し側でDIE("msg");と書いたとき、「1つの文」として扱われる
• if文のelseと組み合わせても構文が壊れない
• マクロの末尾に;を付けて呼び出すのが自然になり、他の文と同じ感覚で使える

このイディオムにより、多文マクロを比較的安全に使えるようになります。

if文と組み合わせる多文マクロの落とし穴

多文マクロで特に危険なのが、if文との組み合わせです。

まず、悪い例から見てみます。

#include <stdio.h>

// 悪い多文マクロの例
#define LOG_AND_INC(x)   \
    printf("x = %d\n", (x)); \
    (x)++

int main(void) {
    int a = 0;

    if (a == 0)
        LOG_AND_INC(a);  // 実際には2文に展開される

    return 0;
}

このマクロは次のように展開されます。

if (a == 0)
    printf("x = %d\n", (a));
(a)++;

結果として、if文の対象はprintfだけになり、(a)++はifの外側で常に実行されることになります。

これは、マクロを書いた側・呼び出した側のどちらから見ても意図しない動作です。

do { … } while(0) で囲んだ場合は、次のように展開されます。

#define LOG_AND_INC(x)          \
    do {                        \
        printf("x = %d\n", (x));\
        (x)++;                  \
    } while (0)

if (a == 0)
    do {
        printf("x = %d\n", (a));
        (a)++;
    } while (0);

これなら、if文全体が1つの文として扱われるため、意図通りの動作になります。

多文マクロを書くときには、do-while(0)イディオムをほぼ必須と考えてよいです。

ブロックスコープとローカル変数を使う場合の注意

多文マクロの中でローカル変数のようなものを扱いたくなることがあります。

例えば、引数を一旦ローカルに保存してから処理したい場合です。

// 悪い例: マクロ内の変数名が衝突する可能性がある
#define SWAP_BAD(a, b)      \
    do {                    \
        int tmp = (a);      \
        (a) = (b);          \
        (b) = tmp;          \
    } while (0)

一見問題なさそうに見えますが、呼び出し側のスコープでtmpという変数が既に存在する場合、名前が衝突して意図しない動作につながる可能性があります。

より安全なパターンとしては、次のような工夫があります。

• かなりユニークな名前を付けて、衝突の可能性を減らす
• GCCやClangの拡張である__typeof__や__auto_typeを使って、型も自動で合わせる
• そもそもローカル変数が必要なほど複雑な処理は、関数やインライン関数に逃がす

標準Cだけで比較的安全に書くなら、例えば次のような形がよく使われます。

// ユニークそうな名前にして衝突リスクを下げた例
#define SWAP_INT(a, b)              \
    do {                            \
        int _swap_tmp_int_ = (a);   \
        (a) = (b);                  \
        (b) = _swap_tmp_int_;       \
    } while (0)

それでも完全に安全とは言い切れないため、「マクロの中でローカル変数を多用しない」「必要なら関数化する」という判断が重要です。

安全な関数マクロ設計のポイントとベストプラクティス

副作用と戻り値ライクなマクロ設計

関数マクロを設計する際の重要なポイントは、「副作用の有無」と「戻り値のように使うかどうか」を明確にすることです。

大きく分けると、次の2種類があります。

• 式マクロ: 値を返すように設計されたマクロ
  • 例: MAX(a, b)、MIN(a, b)、SQUARE(x)
  • 設計方針: 副作用を持たない、引数を複数回評価しないよう注意(ただし完全には防げないため利用側も注意)
• 文マクロ: 文として実行するマクロ
  • 例: LOG(msg)、DIE(msg)、LOCK(m)/UNLOCK(m)
  • 設計方針: 副作用を持つことが多いので、do-while(0)イディオムで1文として扱えるようにする

特に式マクロでは、呼び出し側がMAX(i++, j++)のように書いたときに予期しない振る舞いになるため、マクロのコメントや名前で「副作用を含む式を渡さない」ことを強く示すと安全性が高まります。

デバッグ性と可読性を高めるマクロ命名規則

マクロは型がなく、展開後の姿も直接見えないため、命名規則とコメントで意味を明確にすることが非常に大切です。

典型的なベストプラクティスとしては、次のようなものがあります。

• すべて大文字 + アンダースコアを基本とする
  • 例: MAX、MIN、LOG_DEBUG
• 関数ライクなマクロは「関数でない」ことが分かるように、通常の関数名(小文字またはキャメルケース)とは明確に区別する
• 文マクロは動詞から始めて副作用があることを示す
  • 例: DO_LOG_ERROR、CHECK_AND_RETURN
• ヘッダファイル側で、マクロの説明コメントをきちんと記述する
  • 副作用の有無
  • 引数の評価回数の注意
  • スレッドセーフかどうか

また、デバッグ時にマクロ展開を追いやすくするために、デバッグビルドではマクロを関数に置き換えるというテクニックもあります。

// 例: デバッグ時だけ関数として定義するパターン
#ifdef DEBUG
int max_int_debug(int a, int b);
#define MAX_INT(a, b)  max_int_debug((a), (b))
#else
#define MAX_INT(a, b)  ((a) > (b) ? (a) : (b))
#endif

こうしておけば、デバッグ時にはmax_int_debugとしてステップ実行でき、本番ビルドではマクロ展開により高速に動作させることができます。

関数マクロとインライン関数の使い分け指針

C99以降ではインライン関数が利用できるため、かつて関数マクロで行っていたことの多くはインライン関数で代替可能になりました。

両者の使い分けを整理しておきます。

インライン関数の例

#include <stdio.h>

// C99以降で使えるインライン関数
static inline int max_int_inline(int a, int b) {
    return (a > b) ? a : b;
}

int main(void) {
    int x = 3, y = 5;
    int m = max_int_inline(x, y);

    printf("max = %d\n", m);
    return 0;
}

max = 5

インライン関数は、次の点でマクロより優れています。

• 型安全であり、引数や戻り値の型がチェックされる
• デバッガでステップ実行可能
• マクロのような思わぬ複数回評価や演算子優先順位の問題が起こりにくい
• 名前空間が通常の関数と同じ扱いであり、衝突やグローバルな置換の危険がない

一方で、マクロに向いている場面もあります。

• 型に依存しない汎用コードを書きたい場合
  • 例: MAX(a, b) を int, double, long などさまざまな型で使う
• コンパイル時に条件分岐やコード埋め込みを行いたい場合
  • 例: DEBUG_LOG(msg) をビルドオプションにより完全に無効化する

簡単な指針として、次のように考えるとよいです。

• 「型が特定できる」「C99以降である」 → まずインライン関数を検討する
• 「どうしても型に依存しない処理を書きたい」「条件コンパイルが本質」 → マクロを検討する

このように、「マクロは最後の手段」くらいの位置づけで考えることで、安全かつ可読性の高いコードを書けるようになります。

まとめ

関数マクロは、C言語ならではの強力な機能ですが、テキスト置換であるがゆえの落とし穴も多く潜んでいます。

本記事では、引数付きマクロの基本から、括弧付けの重要性、多文マクロとdo { ... } while(0)イディオム、ローカル変数の扱い、さらにインライン関数との使い分けまで解説しました。

実務では、「型安全が欲しいならインライン関数」「どうしても必要なところだけ慎重に関数マクロ」という方針で設計することが、安全で保守しやすいCコードへの近道です。