Ada masalah terkenal dengan arg kosong untuk makro variadic di C99.

contoh:

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

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

Penggunaan di BAR()atas memang salah menurut standar C99, karena akan diperluas ke:

printf("this breaks!",);

Perhatikan tanda koma - tidak bisa digunakan.

Beberapa kompiler (mis: Visual Studio 2010) akan dengan tenang menyingkirkan koma jejak itu untuk Anda. Kompiler lain (misalnya: GCC) mendukung meletakkan ##di depan __VA_ARGS__, seperti:

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

Tetapi apakah ada cara yang sesuai standar untuk mendapatkan perilaku ini? Mungkin menggunakan beberapa makro?

Saat ini, ##versi ini tampaknya cukup didukung (setidaknya pada platform saya), tetapi saya lebih suka menggunakan solusi yang sesuai standar.

Pre-emptive: Saya tahu saya hanya bisa menulis fungsi kecil. Saya mencoba melakukan ini menggunakan makro.

Sunting : Ini adalah contoh (walaupun sederhana) mengapa saya ingin menggunakan 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);

Ini secara otomatis menambahkan baris baru ke pernyataan logging BAR () saya, dengan asumsi fmtselalu merupakan C-string yang dikutip ganda. Ini TIDAK mencetak baris baru sebagai printf terpisah (), yang menguntungkan jika logging-buffered dan berasal dari berbagai sumber secara tidak sinkron.

Dimungkinkan untuk menghindari penggunaan ,##__VA_ARGS__ekstensi GCC jika Anda bersedia menerima beberapa batas atas yang dikodekan pada jumlah argumen yang dapat Anda sampaikan ke makro variadic Anda, seperti yang dijelaskan dalam jawaban Richard Hansen untuk pertanyaan ini . Namun, jika Anda tidak ingin memiliki batas seperti itu, sejauh yang saya ketahui, tidak mungkin hanya menggunakan fitur preprosesor yang ditentukan C99; Anda harus menggunakan beberapa ekstensi ke bahasa. dentang dan icc telah mengadopsi ekstensi GCC ini, tetapi MSVC belum.

Kembali pada tahun 2001 saya menulis ekstensi GCC untuk standardisasi (dan ekstensi terkait yang memungkinkan Anda menggunakan nama selain __VA_ARGS__untuk parameter-sisanya) dalam dokumen N976 , tetapi yang tidak menerima respons apa pun dari komite; Saya bahkan tidak tahu apakah ada yang membacanya. Pada 2016 itu diusulkan lagi di N2023 , dan saya mendorong siapa pun yang tahu bagaimana proposal itu akan memberi tahu kami di komentar.

Ada trik penghitungan argumen yang bisa Anda gunakan.

Berikut adalah satu cara yang sesuai standar untuk menerapkan BAR()contoh kedua dalam pertanyaan jwd:

#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;
}

Trik yang sama ini digunakan untuk:

• hitung jumlah argumen
• perluas berbeda tergantung pada jumlah argumen
• tambahkan ke __VA_ARGS__

Penjelasan

Strateginya adalah untuk memisahkan __VA_ARGS__ke dalam argumen pertama dan sisanya (jika ada). Ini memungkinkan untuk memasukkan barang setelah argumen pertama tetapi sebelum argumen kedua (jika ada).

FIRST()

Makro ini hanya memperluas argumen pertama, membuang sisanya.

Implementasinya sangat mudah. The throwawayArgumen memastikan bahwa FIRST_HELPER()mendapat dua argumen, yang diperlukan karena ...kebutuhan minimal satu. Dengan satu argumen, itu berkembang sebagai berikut:

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

Dengan dua atau lebih, itu mengembang sebagai berikut:

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

REST()

Makro ini mengembang ke segala sesuatu kecuali argumen pertama (termasuk koma setelah argumen pertama, jika ada lebih dari satu argumen).

Implementasi makro ini jauh lebih rumit. Strategi umum adalah menghitung jumlah argumen (satu atau lebih dari satu) dan kemudian berkembang menjadi REST_HELPER_ONE()(jika hanya satu argumen yang diberikan) atau REST_HELPER_TWOORMORE()(jika dua atau lebih argumen diberikan). REST_HELPER_ONE()cukup mengembang menjadi tidak ada - tidak ada argumen setelah yang pertama, jadi argumen yang tersisa adalah set kosong. REST_HELPER_TWOORMORE()juga mudah - itu mengembang ke koma diikuti oleh segala sesuatu kecuali argumen pertama.

Argumen dihitung menggunakan NUM()makro. Makro ini diperluas ke ONEjika hanya satu argumen yang diberikan, TWOORMOREjika antara dua dan sembilan argumen diberikan, dan istirahat jika 10 atau lebih argumen diberikan (karena diperluas ke argumen 10).

The NUM()makro menggunakan SELECT_10TH()makro untuk menentukan jumlah argumen. Seperti namanya, SELECT_10TH()cukup memperluas argumen ke-10. Karena ellipsis, SELECT_10TH()perlu diberikan setidaknya 11 argumen (standar mengatakan bahwa harus ada setidaknya satu argumen untuk ellipsis). Inilah sebabnya mengapa NUM()lewat throwawaysebagai argumen terakhir (tanpa itu, melewati satu argumen untuk NUM()akan menghasilkan hanya 10 argumen yang diteruskan keSELECT_10TH() , yang akan melanggar standar).

Pemilihan salah satu REST_HELPER_ONE()atau REST_HELPER_TWOORMORE()dilakukan dengan menggabungkan REST_HELPER_dengan ekspansi NUM(__VA_ARGS__)di REST_HELPER2(). Perhatikan bahwa tujuannya REST_HELPER()adalah untuk memastikan bahwa NUM(__VA_ARGS__)sepenuhnya diperluas sebelum digabungkan dengan REST_HELPER_.

Ekspansi dengan satu argumen berbunyi sebagai berikut:

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. (kosong)

Ekspansi dengan dua atau lebih argumen berjalan sebagai berikut:

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

Bukan solusi umum, tetapi dalam hal printf Anda dapat menambahkan baris baru seperti:

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

Saya percaya ini mengabaikan argumen tambahan yang tidak dirujuk dalam format string. Jadi Anda bahkan mungkin bisa lolos dengan:

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

Saya tidak percaya C99 disetujui tanpa cara standar untuk melakukan ini. AFAICT masalah ada di C ++ 11 juga.

Ada cara untuk menangani kasus spesifik ini menggunakan sesuatu seperti Boost.Prosesor . Anda dapat menggunakan BOOST_PP_VARIADIC_SIZE untuk memeriksa ukuran daftar argumen, dan kemudian memperluas ke makro lain. Satu kekurangannya adalah tidak bisa membedakan antara argumen 0 dan 1, dan alasannya menjadi jelas setelah Anda mempertimbangkan yang berikut ini:

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

Daftar argumen makro kosong sebenarnya terdiri dari satu argumen yang kebetulan kosong.

Dalam hal ini, kami beruntung karena makro yang Anda inginkan selalu memiliki setidaknya 1 argumen, kami dapat mengimplementasikannya sebagai dua makro "kelebihan":

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

Dan kemudian makro lain untuk beralih di antara mereka, seperti:

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

atau

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

Mana pun yang Anda temukan lebih mudah dibaca (saya lebih suka yang pertama karena memberi Anda bentuk umum untuk memuat makro pada jumlah argumen).

Dimungkinkan juga untuk melakukan ini dengan makro tunggal dengan mengakses dan mengubah daftar argumen variabel, tetapi cara ini kurang dapat dibaca, dan sangat spesifik untuk masalah ini:

#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__)))) \
    /**/

Juga, mengapa tidak ada BOOST_PP_ARRAY_ENUM_TRAILING? Itu akan membuat solusi ini tidak terlalu mengerikan.

Sunting: Baiklah, ini adalah BOOST_PP_ARRAY_ENUM_TRAILING, dan versi yang menggunakannya (ini sekarang solusi favorit saya):

#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__)))) \
    /**/

Makro yang sangat sederhana yang saya gunakan untuk mencetak debug:

#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;
}

Tidak peduli berapa banyak argumen yang diteruskan ke DBG, tidak ada peringatan c99.

Caranya adalah __DBG_INTmenambahkan param dummy sehingga ...akan selalu memiliki setidaknya satu argumen dan c99 puas.

Saya mengalami masalah yang sama baru-baru ini, dan saya yakin ada solusi.

Ide kuncinya adalah bahwa ada cara untuk menulis makro NUM_ARGSuntuk menghitung jumlah argumen yang diberikan makro variadic. Anda bisa menggunakan variasi NUM_ARGSuntuk membangun NUM_ARGS_CEILING2, yang dapat memberi tahu Anda apakah makro variadik diberikan 1 argumen atau 2 atau lebih argumen. Kemudian Anda bisa menulis Barmakro Anda sehingga menggunakan NUM_ARGS_CEILING2danCONCAT mengirim argumennya ke salah satu dari dua makro pembantu: satu yang mengharapkan tepat 1 argumen, dan yang lain mengharapkan sejumlah variabel argumen lebih besar dari 1.

Berikut adalah contoh di mana saya menggunakan trik ini untuk menulis makro UNIMPLEMENTED, yang sangat mirip dengan BAR:

LANGKAH 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

LANGKAH 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)

Langkah 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__)

LANGKAH 3:

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

Di mana CONCAT diimplementasikan dengan cara biasa. Sebagai petunjuk singkat, jika hal di atas tampak membingungkan: tujuan CONCAT ada untuk memperluas ke "panggilan" makro lainnya.

Perhatikan bahwa NUM_ARGS sendiri tidak digunakan. Saya hanya memasukkannya untuk menggambarkan trik dasar di sini. Lihatlah blog Pens Jens Gustedt untuk mendapatkan perawatan yang bagus.

Dua catatan:

• NUM_ARGS terbatas dalam jumlah argumen yang ditangani. Milik saya hanya dapat menangani hingga 20, meskipun jumlahnya benar-benar sewenang-wenang.

• NUM_ARGS, seperti yang ditunjukkan, memiliki jebakan karena ia mengembalikan 1 ketika diberikan 0 argumen. Intinya adalah bahwa NUM_ARGS secara teknis menghitung [koma + 1], dan bukan argumen. Dalam kasus khusus ini, ini benar-benar bermanfaat bagi kita. _UNIMPLEMENTED1 akan menangani token kosong dengan baik dan itu menyelamatkan kita dari keharusan menulis _UNIMPLEMENTED0. Gustedt memiliki solusi untuk itu juga, meskipun saya belum menggunakannya dan saya tidak yakin apakah itu akan berhasil untuk apa yang kami lakukan di sini.

Ini adalah versi sederhana yang saya gunakan. Itu didasarkan pada teknik-teknik hebat dari jawaban-jawaban lain di sini, begitu banyak alat bantu untuk mereka:

#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;
}

Itu dia.

Seperti dengan solusi lain ini terbatas pada jumlah argumen makro. Untuk mendukung lebih banyak, tambahkan lebih banyak parameter _SELECT, dan lebih banyak Nargumen. Nama argumen menghitung mundur (bukan naik) untuk berfungsi sebagai pengingat bahwa SUFFIXargumen berbasis hitungan disediakan dalam urutan terbalik.

Solusi ini memperlakukan 0 argumen seolah-olah itu adalah 1 argumen. Jadi BAR()secara nominal "bekerja", karena ia mengembang ke _SELECT(_BAR,,N,N,N,N,1)(), yang mengembang ke _BAR_1()(), yang mengembang ke printf("\n").

Jika mau, Anda bisa berkreasi dengan menggunakan _SELECTdan menyediakan makro yang berbeda untuk jumlah argumen yang berbeda. Sebagai contoh, di sini kita memiliki makro LOG yang mengambil argumen 'level' sebelum format. Jika format tidak ada, ia mencatat "(tidak ada pesan)", jika hanya ada 1 argumen, ia akan mencatatnya melalui "% s", jika tidak maka akan memperlakukan argumen format sebagai string format printf untuk argumen yang tersisa.

#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
*/

Dalam situasi Anda (setidaknya 1 argumen hadir, tidak pernah 0), Anda dapat mendefinisikan BARsebagai BAR(...), gunakan Jens Gustedt HAS_COMMA(...) untuk mendeteksi koma dan kemudian mengirim ke BAR0(Fmt)atau BAR1(Fmt,...)sesuai.

Ini:

#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);
}

kompilasi dengan -pedantictanpa peringatan.

C (gcc) , 762 byte

#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);
}

Cobalah online!

Mengasumsikan:

• Tidak ada arg yang mengandung koma atau braket
• Tanpa arg berisi A~ G(bisa mengganti nama menjadi hard_collide)

Solusi standar adalah menggunakan FOOalih-alih BAR. Ada beberapa kasus aneh dalam menyusun ulang argumen yang mungkin tidak bisa dilakukan untuk Anda (walaupun saya yakin seseorang dapat membuat hacks cerdas untuk membongkar dan memasang kembali secara __VA_ARGS__kondisional berdasarkan jumlah argumen di dalamnya!) Tetapi secara umum menggunakan FOO"biasanya" hanya bekerja.