Início / coding / Perguntas / 79070556
Accepted
Abdulmalek Almkainzi
Asked: 2024-10-09 21:40:14 +0800 CST

Detectar um argumento de macro entre parênteses em C

  • 772

Quero uma macro para detectar se o argumento passado está entre parênteses ou não e, se for o caso, chamar uma macro diferente.

por exemplo

#define FOO(obj) BAR obj
#define BAR(...) func(__VA_ARGS__)
#define BAR

Se eu chamar isso com FOO((1, 2, 3))ele se expandiria para func(1, 2, 3). Mas se eu chamar isso com FOO(1)ele deveria se expandir para1

Eu sei que sobrecarga de macro não é uma coisa em C, mas estou pensando se há outra maneira de atingir esse comportamento a partir de FOO. Eu pesquisei vários truques de macro, mas não consegui descobrir uma maneira de fazer isso.

Estou trabalhando em uma biblioteca de macros e preciso desse comportamento exato.

c

2 respostas

  1. #define FOO(...) DETAIL_FOO1( DETAIL_FOO0 __VA_ARGS__ ) )
#define DETAIL_FOO0(...) DETAIL_FOO0_ __VA_ARGS__
#define DETAIL_FOO1(...) DETAIL_FOO2(__VA_ARGS__)
#define DETAIL_FOO2(...) DETAIL_FOO3_##__VA_ARGS__
#define DETAIL_FOO3_DETAIL_FOO0 (
#define DETAIL_FOO3_DETAIL_FOO0_ bar(

FOO(1) // (1)
FOO((1,2,3)) // bar(1,2,3)

    Neste caso, FOO(1)expande para (1)e não 1, mas isso provavelmente é mais desejável.

    Acontece que isso aceita incorretamente FOO((1,2)3), expandindo-o para bar(1,2 3). Com ginástica macro adicional, você pode rejeitar isso:

    #define FOO(...) DETAIL_FOO1( DETAIL_FOOA(__VA_ARGS__) ) )
#define DETAIL_FOOA(...) DETAIL_FOO0 __VA_ARGS__ )
#define DETAIL_FOO0(...) DETAIL_FOO0_ __VA_ARGS__ REQUIRE_EMPTY(
#define DETAIL_FOO1(...) DETAIL_FOO2(__VA_ARGS__)
#define DETAIL_FOO2(...) DETAIL_FOO3_##__VA_ARGS__
#define DETAIL_FOO3_DETAIL_FOO0 ( IDENTITY(
#define DETAIL_FOO3_DETAIL_FOO0_ bar(
#define REQUIRE_EMPTY()
#define IDENTITY(...) __VA_ARGS__
    • 4
  2. Best Answer

    Acabei de escrever isso. Isso pode ser simplificado, é só a primeira versão que eu peguei no godbolt que funcionou. Deve ser o suficiente para você começar.

    // if I call this with FOO((1, 2, 3)) it'd expand to func(1, 2, 3).
// But if I call it with FOO(1) it should expand to 1

#define ESCAPE2(...)  __VA_ARGS__
#define ESCAPE(...)  ESCAPE2 __VA_ARGS__
#define COMMA(...)     ,
#define FIRST(T, ...)  T
// from https://gustedt.wordpress.com/2010/06/08/detect-empty-macro-arguments/
#define ARG16(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, ...) _15
#define HAS_COMMA(...) ARG16(__VA_ARGS__, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0)
#define CONCAT(a, b)  a##b
#define XCONCAT(a, b)  CONCAT(a, b)
#define IF_1(a, b)  a
#define IF_0(a, b)  b
#define FOO(...)  \
        ESCAPE( \
            XCONCAT(IF_, HAS_COMMA(FIRST( COMMA __VA_ARGS__ () ))) \
            ((func __VA_ARGS__), (__VA_ARGS__)) \
        )

FOO((1,2,3)) // func (1,2,3)
FOO((1))  // func (1)
FOO(1)   // 1
FOO(1,2)   // 1,2

    Isso parece melhor. Depois de converter __VA_ARGS__para uma vírgula, é só uma questão de obter uma posição arg adequada.

    #define FOO_ESCAPE(...)  __VA_ARGS__
#define FOO_COMMA(...)     ,
#define FOO_FIRST(T, ...)  T
#define FOO_THIRD(_1,_2,_3,...)  \
        FOO_ESCAPE _3
#define FOO_XTHIRD(...)  \
        FOO_THIRD(__VA_ARGS__)
#define FOO(...)  \
        FOO_XTHIRD(__VA_OPT__(FOO_FIRST(FOO_COMMA __VA_ARGS__)), \
            (func __VA_ARGS__), (__VA_ARGS__) )
FOO((1,2,3))
FOO((1))
FOO()
FOO(1)
FOO(1,2)
    • 3

relate perguntas