web-dev-qa-db-ja.com

GCCの## __ VA_ARGS__トリックの標準的な代替手段？

C99の可変長マクロには、空の引数を持つ well-known問題 があります。

例：

#define FOO(...)       printf(__VA_ARGS__)
#define BAR(fmt, ...)  printf(fmt, __VA_ARGS__)

FOO("this works fine");
BAR("this breaks!");

上記のBAR()の使用は、次のように展開されるため、C99標準によれば実際には正しくありません。

printf("this breaks!",);

末尾のコンマに注意してください-実行できません。

一部のコンパイラ（例：Visual Studio 2010）は、末尾のコンマを静かに取り除きます。他のコンパイラ（例：GCC）は、次のように##の前に__VA_ARGS__を置くことをサポートしています。

#define BAR(fmt, ...)  printf(fmt, ##__VA_ARGS__)

しかし、この動作を実現する標準準拠の方法はありますか？おそらく複数のマクロを使用していますか？

現時点では、##バージョンはかなりサポートされているように見えます（少なくとも私のプラットフォームでは）が、実際には標準に準拠したソリューションを使用したいです。

プリエンプティブ：小さな関数を書くことができることを知っています。マクロを使用してこれを実行しようとしています。

Edit：ここに、BAR（）を使用したい理由の例（単純ですが）を示します。

#define BAR(fmt, ...)  printf(fmt "\n", ##__VA_ARGS__)

BAR("here is a log message");
BAR("here is a log message with a param: %d", 42);

これにより、fmtが常に二重引用符で囲まれたC文字列であると想定して、BAR（）ロギングステートメントに改行が自動的に追加されます。改行を個別のprintf（）として出力することはありません。これは、ロギングがラインバッファリングされ、複数のソースから非同期的に取得される場合に有利です。

cc99c-preprocessorvariadic-macros
137
jwd

Richard Hansenのこれに対する答えで説明されているように、可変引数マクロに渡すことができる引数の数のハードコードされた上限を受け入れたい場合、GCCの,##__VA_ARGS__拡張の使用を避けることが可能です質問 。ただし、このような制限が必要ない場合は、私の知る限り、C99指定のプリプロセッサ機能のみを使用することはできません。言語の拡張機能を使用する必要があります。 clangとiccはこのGCC拡張を採用していますが、MSVCは採用していません。

2001年に、標準化のためにGCC拡張機能（および、rest-parameterに__VA_ARGS__以外の名前を使用できる関連拡張機能）を document N976 で作成しましたが、委員会からのあらゆる回答。誰も読んだかどうかさえ知りません。 2016年に N202 で再度提案されました。この提案がどのようにコメントで知らせてくれるかを知っている人なら誰でもお勧めします。

60
zwol

使用できる引数カウントのトリックがあります。

Jwdの質問の2番目のBAR()の例を実装する1つの標準準拠の方法を次に示します。

#include <stdio.h>

#define BAR(...) printf(FIRST(__VA_ARGS__) "\n" REST(__VA_ARGS__))

/* expands to the first argument */
#define FIRST(...) FIRST_HELPER(__VA_ARGS__, throwaway)
#define FIRST_HELPER(first, ...) first

/*
 * if there's only one argument, expands to nothing.  if there is more
 * than one argument, expands to a comma followed by everything but
 * the first argument.  only supports up to 9 arguments but can be
 * trivially expanded.
 */
#define REST(...) REST_HELPER(NUM(__VA_ARGS__), __VA_ARGS__)
#define REST_HELPER(qty, ...) REST_HELPER2(qty, __VA_ARGS__)
#define REST_HELPER2(qty, ...) REST_HELPER_##qty(__VA_ARGS__)
#define REST_HELPER_ONE(first)
#define REST_HELPER_TWOORMORE(first, ...) , __VA_ARGS__
#define NUM(...) \
    SELECT_10TH(__VA_ARGS__, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE,\
                TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, ONE, throwaway)
#define SELECT_10TH(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, ...) a10

int
main(int argc, char *argv[])
{
    BAR("first test");
    BAR("second test: %s", "a string");
    return 0;
}

これと同じトリックを使用して：

説明

戦略は、__VA_ARGS__を最初の引数と残りの引数（ある場合）に分離することです。これにより、最初の引数の後、2番目の引数（存在する場合）の前にデータを挿入できます。

FIRST()

このマクロは、最初の引数に単純に展開し、残りを破棄します。

実装は簡単です。 throwaway引数は、FIRST_HELPER()が2つの引数を取得することを保証します。これは、...が少なくとも1つを必要とするために必要です。引数が1つの場合、次のように展開されます。

  1. FIRST(firstarg)
  2. FIRST_HELPER(firstarg, throwaway)
  3. firstarg

2つ以上の場合、次のように展開されます。

  1. FIRST(firstarg, secondarg, thirdarg)
  2. FIRST_HELPER(firstarg, secondarg, thirdarg, throwaway)
  3. firstarg

REST()

このマクロは、最初の引数（複数の引数がある場合、最初の引数の後のコンマを含む）を除くすべてに展開されます。

このマクロの実装ははるかに複雑です。一般的な戦略は、引数の数（1つまたは複数）をカウントし、REST_HELPER_ONE()（引数が1つだけの場合）またはREST_HELPER_TWOORMORE()（引数が2つ以上の場合）のいずれかに展開することです。 REST_HELPER_ONE()は単に何も展開しない-最初の引数の後に引数がないため、残りの引数は空のセットです。 REST_HELPER_TWOORMORE()も簡単です-最初の引数を除くすべてが続くコンマに展開されます。

引数は、NUM()マクロを使用してカウントされます。このマクロは、引数が1つだけ指定された場合はONEに、2〜9個の引数が指定された場合はTWOORMOREに、10個以上の引数が指定された場合はブレークします（10番目の引数に拡張されるため）。

NUM()マクロは、SELECT_10TH()マクロを使用して引数の数を決定します。名前が示すように、SELECT_10TH()は単に10番目の引数に展開されます。省略記号のため、SELECT_10TH()には少なくとも11個の引数を渡す必要があります（標準では、省略記号には少なくとも1つの引数が必要であるとされています）。これが、NUM()がthrowawayを最後の引数として渡す理由です（引数がない場合、NUM()に1つの引数を渡すと、SELECT_10TH()に渡される引数は10個になり、標準に違反します）。

REST_HELPER_ONE()またはREST_HELPER_TWOORMORE()の選択は、NUM(__VA_ARGS__)内のREST_HELPER2()の展開とREST_HELPER_を連結することによって行われます。 REST_HELPER()の目的は、NUM(__VA_ARGS__)がREST_HELPER_と連結される前に完全に展開されるようにすることです。

1つの引数を持つ展開は次のようになります。

  1. REST(firstarg)
  2. REST_HELPER(NUM(firstarg), firstarg)
  3. REST_HELPER2(SELECT_10TH(firstarg, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, ONE, throwaway), firstarg)
  4. REST_HELPER2(ONE, firstarg)
  5. REST_HELPER_ONE(firstarg)
  6. （空の）

2つ以上の引数を使用した展開は次のようになります。

  1. REST(firstarg, secondarg, thirdarg)
  2. REST_HELPER(NUM(firstarg, secondarg, thirdarg), firstarg, secondarg, thirdarg)
  3. REST_HELPER2(SELECT_10TH(firstarg, secondarg, thirdarg, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, ONE, throwaway), firstarg, secondarg, thirdarg)
  4. REST_HELPER2(TWOORMORE, firstarg, secondarg, thirdarg)
  5. REST_HELPER_TWOORMORE(firstarg, secondarg, thirdarg)
  6. , secondarg, thirdarg
108
Richard Hansen

一般的な解決策ではありませんが、printfの場合、次のような改行を追加できます。

#define BAR_HELPER(fmt, ...) printf(fmt "\n%s", __VA_ARGS__)
#define BAR(...) BAR_HELPER(__VA_ARGS__, "")

フォーマット文字列で参照されていない余分な引数は無視されると思います。だから、おそらくあなたも逃げることができます：

#define BAR_HELPER(fmt, ...) printf(fmt "\n", __VA_ARGS__)
#define BAR(...) BAR_HELPER(__VA_ARGS__, 0)

これを行う標準的な方法がなければ、C99が承認されたとは思えません。 A ++、問題はC++ 11にも存在します。

15
Marsh Ray

Boost.Preprocessor のようなものを使用して、この特定のケースを処理する方法があります。 BOOST_PP_VARIADIC_SIZE を使用して引数リストのサイズを確認し、条件付きで別のマクロに展開できます。これの1つの欠点は、0と1の引数を区別できないことです。この理由は、次のことを考慮すると明らかになります。

BOOST_PP_VARIADIC_SIZE()      // expands to 1
BOOST_PP_VARIADIC_SIZE(,)     // expands to 2
BOOST_PP_VARIADIC_SIZE(,,)    // expands to 3
BOOST_PP_VARIADIC_SIZE(a)     // expands to 1
BOOST_PP_VARIADIC_SIZE(a,)    // expands to 2
BOOST_PP_VARIADIC_SIZE(,b)    // expands to 2
BOOST_PP_VARIADIC_SIZE(a,b)   // expands to 2
BOOST_PP_VARIADIC_SIZE(a, ,c) // expands to 3

空のマクロ引数リストは、実際には空の引数が1つだけ含まれています。

この場合、希望するマクロには常に少なくとも1つの引数があり、2つの「オーバーロード」マクロとして実装できるため、幸運です。

#define BAR_0(fmt) printf(fmt "\n")
#define BAR_1(fmt, ...) printf(fmt "\n", __VA_ARGS__)

そして、それらを切り替える別のマクロ、例えば：

#define BAR(...) \
    BOOST_PP_CAT(BAR_, BOOST_PP_GREATER(
        BOOST_PP_VARIADIC_SIZE(__VA_ARGS__), 1))(__VA_ARGS__) \
    /**/

または

#define BAR(...) BOOST_PP_IIF( \
    BOOST_PP_GREATER(BOOST_PP_VARIADIC_SIZE(__VA_ARGS__), 1), \
        BAR_1, BAR_0)(__VA_ARGS__) \
    /**/

より読みやすいと思うものはどれでも（引数の数でマクロをオーバーロードするための一般的な形式を提供するので、私は最初のものを好む）。

可変引数リストにアクセスして変更することにより、単一のマクロでこれを行うこともできますが、読みにくいため、この問題に非常に特有です。

#define BAR(...) printf( \
    BOOST_PP_VARIADIC_ELEM(0, __VA_ARGS__) "\n" \
    BOOST_PP_COMMA_IF( \
        BOOST_PP_GREATER(BOOST_PP_VARIADIC_SIZE(__VA_ARGS__), 1)) \
    BOOST_PP_ARRAY_ENUM(BOOST_PP_ARRAY_POP_FRONT( \
        BOOST_PP_VARIADIC_TO_ARRAY(__VA_ARGS__)))) \
    /**/

また、BOOST_PP_ARRAY_ENUM_TRAILINGがないのはなぜですか？これにより、このソリューションの恐ろしさがはるかに少なくなります。

編集：さて、ここにBOOST_PP_ARRAY_ENUM_TRAILINGとそれを使用するバージョンがあります（これが現在私のお気に入りのソリューションです）：

#define BOOST_PP_ARRAY_ENUM_TRAILING(array) \
    BOOST_PP_COMMA_IF(BOOST_PP_ARRAY_SIZE(array)) BOOST_PP_ARRAY_ENUM(array) \
    /**/

#define BAR(...) printf( \
    BOOST_PP_VARIADIC_ELEM(0, __VA_ARGS__) "\n" \
    BOOST_PP_ARRAY_ENUM_TRAILING(BOOST_PP_ARRAY_POP_FRONT( \
        BOOST_PP_VARIADIC_TO_ARRAY(__VA_ARGS__)))) \
    /**/
10
DRayX

最近、同様の問題に遭遇しましたが、解決策があると思います。

重要な考え方は、マクロNUM_ARGSを記述して、可変長マクロに与えられた引数の数を数える方法があるということです。 NUM_ARGSのバリエーションを使用してNUM_ARGS_CEILING2を構築できます。これにより、可変引数マクロに1つの引数または2つ以上の引数が与えられているかどうかを確認できます。次に、Barマクロを記述して、NUM_ARGS_CEILING2およびCONCATを使用して、2つのヘルパーマクロの1つに引数を送信します。 1より大きい引数の数。

以下に、このトリックを使用してマクロUNIMPLEMENTEDを記述する例を示します。これはBARと非常によく似ています。

ステップ1：

/** 
 * A variadic macro which counts the number of arguments which it is
 * passed. Or, more precisely, it counts the number of commas which it is
 * passed, plus one.
 *
 * Danger: It can't count higher than 20. If it's given 0 arguments, then it
 * will evaluate to 1, rather than to 0.
 */

#define NUM_ARGS(...)                                                   \
    NUM_ARGS_COUNTER(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13,       \
                     12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)    

#define NUM_ARGS_COUNTER(a1, a2, a3, a4, a5, a6, a7,        \
                         a8, a9, a10, a11, a12, a13,        \
                         a14, a15, a16, a17, a18, a19, a20, \
                         N, ...)                            \
    N

STEP 1.5：

/*
 * A variant of NUM_ARGS that evaluates to 1 if given 1 or 0 args, or
 * evaluates to 2 if given more than 1 arg. Behavior is nasty and undefined if
 * it's given more than 20 args.
 */

#define NUM_ARGS_CEIL2(...)                                           \
    NUM_ARGS_COUNTER(__VA_ARGS__, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, \
                     2, 2, 2, 2, 2, 2, 2, 1)

ステップ2：

#define _UNIMPLEMENTED1(msg)                                        \
    log("My creator has forsaken me. %s:%s:%d." msg, __FILE__,      \
        __func__, __LINE__)

#define _UNIMPLEMENTED2(msg, ...)                                   \
    log("My creator has forsaken me. %s:%s:%d." msg, __FILE__,      \
        __func__, __LINE__, __VA_ARGS__)

ステップ3：

#define UNIMPLEMENTED(...)                                              \
    CONCAT(_UNIMPLEMENTED, NUM_ARGS_CEIL2(__VA_ARGS__))(__VA_ARGS__)

CONCATは通常の方法で実装されます。簡単なヒントとして、上記がわかりにくい場合は、CONCATの目標は別のマクロ「呼び出し」に拡張することです。

NUM_ARGS自体は使用されないことに注意してください。ここで基本的なトリックを説明するためにそれを含めました。 Jens GustedtのP99ブログ を参照してください。

2つのメモ：

  • NUM_ARGSは、処理する引数の数に制限があります。鉱山は最大20までしか処理できませんが、数は完全に任意です。

  • NUM_ARGSには、示されているように、引数が0の場合に1を返すという落とし穴があります。その要点は、NUM_ARGSが技術的に[コンマ+ 1]をカウントし、引数ではないことです。この特定のケースでは、実際に私たちにとって有利に機能します。 _UNIMPLEMENTED1は空のトークンを正常に処理し、_UNIMPLEMENTED0を記述する必要がなくなります。 Gustedtにも回避策がありますが、私は使用していませんが、ここで行っていることで機能するかどうかはわかりません。

5
User123abc

デバッグ印刷に使用している非常に単純なマクロ：

#define __DBG_INT(fmt, ...) printf(fmt "%s", __VA_ARGS__);
#define DBG(...) __DBG_INT(__VA_ARGS__, "\n")

int main() {
        DBG("No warning here");
        DBG("and we can add as many arguments as needed. %s", "Nice!");
        return 0;
}

DBGに渡される引数の数に関係なく、c99警告はありません。

トリックは、__DBG_INTダミーパラメーターを追加することです。したがって、...は常に少なくとも1つの引数を持ち、c99が満たされます。

4
SimonW

これは私が使用する簡易バージョンです。ここにある他の答えの素晴らしいテクニックに基づいているので、それらに対する多くの小道具があります：

#define _SELECT(PREFIX,_5,_4,_3,_2,_1,SUFFIX,...) PREFIX ## _ ## SUFFIX

#define _BAR_1(fmt)      printf(fmt "\n")
#define _BAR_N(fmt, ...) printf(fmt "\n", __VA_ARGS__);
#define BAR(...) _SELECT(_BAR,__VA_ARGS__,N,N,N,N,1)(__VA_ARGS__)

int main(int argc, char *argv[]) {
    BAR("here is a log message");
    BAR("here is a log message with a param: %d", 42);
    return 0;
}

それだけです。

他のソリューションと同様に、これはマクロの引数の数に制限されます。さらにサポートするには、_SELECTにパラメーターを追加し、N引数を追加します。引数名は、カウントベースのSUFFIX引数が逆の順序で提供されることを思い出させるために、（上ではなく）カウントダウンします。

このソリューションは、1つの引数であるかのように0個の引数を扱います。したがって、BAR()は_SELECT(_BAR,,N,N,N,N,1)()に展開され、_BAR_1()()に展開され、printf("\n")に展開されるため、名目上は「機能します」。

必要に応じて、_SELECTを使用してクリエイティブを作成し、引数の数に応じて異なるマクロを提供できます。たとえば、フォーマットの前に「レベル」引数を取るLOGマクロがあります。形式が欠落している場合、「（メッセージなし）」をログに記録し、引数が1つしかない場合は「％s」を介してログを記録します。

#define _LOG_1(lvl)          printf("[%s] (no message)\n", #lvl)
#define _LOG_2(lvl,fmt)      printf("[%s] %s\n", #lvl, fmt)
#define _LOG_N(lvl,fmt, ...) printf("[%s] " fmt "\n", #lvl, __VA_ARGS__)
#define LOG(...) _SELECT(_LOG,__VA_ARGS__,N,N,N,2,1)(__VA_ARGS__)

int main(int argc, char *argv[]) {
    LOG(INFO);
    LOG(DEBUG, "here is a log message");
    LOG(WARN, "here is a log message with param: %d", 42);
    return 0;
}
/* outputs:
[INFO] (no message)
[DEBUG] here is a log message
[WARN] here is a log message with param: 42
*/
1
ɲeuroburɳ

C（gcc） 、762バイト

#define EMPTYFIRST(x,...) A x (B)
#define A(x) x()
#define B() ,

#define EMPTY(...) C(EMPTYFIRST(__VA_ARGS__) SINGLE(__VA_ARGS__))
#define C(...) D(__VA_ARGS__)
#define D(x,...) __VA_ARGS__

#define SINGLE(...) E(__VA_ARGS__, B)
#define E(x,y,...) C(y(),)

#define NONEMPTY(...) F(EMPTY(__VA_ARGS__) D, B)
#define F(...) G(__VA_ARGS__)
#define G(x,y,...) y()

#define STRINGIFY(...) STRINGIFY2(__VA_ARGS__)
#define STRINGIFY2(...) #__VA_ARGS__

#define BAR(fmt, ...) printf(fmt "\n" NONEMPTY(__VA_ARGS__) __VA_ARGS__)

int main() {
    puts(STRINGIFY(NONEMPTY()));
    puts(STRINGIFY(NONEMPTY(1)));
    puts(STRINGIFY(NONEMPTY(,2)));
    puts(STRINGIFY(NONEMPTY(1,2)));

    BAR("here is a log message");
    BAR("here is a log message with a param: %d", 42);
}

オンラインで試してみてください！

想定：

  • 引数にカンマまたはブラケットが含まれていません
  • A〜Gを含む引数はありません（名前をhard_collideに変更できます）
0
l4m2

あなたの状況（少なくとも1つの引数が存在し、0にはならない）では、BARをBAR(...)として定義し、 Jens Gustedt'sHAS_COMMA(...)を使用してコンマを検出し、 BAR0(Fmt)またはBAR1(Fmt,...)に応じてディスパッチします。

この：

#define HAS_COMMA(...) HAS_COMMA_16__(__VA_ARGS__, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0)
#define HAS_COMMA_16__(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, ...) _15
#define CAT_(X,Y) X##Y
#define CAT(X,Y) CAT_(X,Y)
#define BAR(.../*All*/) CAT(BAR,HAS_COMMA(__VA_ARGS__))(__VA_ARGS__)
#define BAR0(X) printf(X "\n")
#define BAR1(X,...) printf(X "\n",__VA_ARGS__)


#include <stdio.h>
int main()
{
    BAR("here is a log message");
    BAR("here is a log message with a param: %d", 42);
}

警告なしで-pedanticでコンパイルします。

0
PSkocik