Com o maior respeito a Derek Ledbetter , David Sorkovsky , Syphorlate por suas respostas, junto com o método engenhoso para detectar macro argumentos vazios por Jens Gustedt em
https://gustedt.wordpress.com/2010/06/08/detect-empty-macro-arguments/
finalmente, saio com algo que incorpora todos os truques, para que a solução
- Usa apenas macros C99 padrão para atingir sobrecarga de função, nenhuma extensão GCC / CLANG / MSVC envolvida (ou seja, deglutição de vírgula pela expressão específica
, ##__VA_ARGS__para GCC / CLANG e deglutição implícita por ##__VA_ARGS__para MSVC). Então fique à vontade para passar pelo que falta--std=c99 para o seu compilador se desejar =)
- Funciona com nenhum argumento , bem como um número ilimitado de argumentos , se você expandir ainda mais para atender às suas necessidades
Funciona razoavelmente em várias plataformas , pelo menos testado para
- GNU / Linux + GCC (GCC 4.9.2 no CentOS 7.0 x86_64)
- GNU / Linux + CLANG / LLVM , (CLANG / LLVM 3.5.0 no CentOS 7.0 x86_64)
- OS X + Xcode , (XCode 6.1.1 no OS X Yosemite 10.10.1)
- Windows + Visual Studio , (Visual Studio 2013 Atualização 4 no Windows 7 SP1 de 64 bits)
Para os preguiçosos, basta pular para o último deste post para copiar a fonte. Abaixo está a explicação detalhada, o que esperançosamente ajuda e inspira todas as pessoas que procuram o__VA_ARGS__ soluções como eu. =)
É assim que funciona. Primeiro defina a "função" visível ao usuário sobrecarregado, I nomeou-o create, e a definição da função reais relacionados realCreate, e as definições de macros com diferente número de argumentos CREATE_2, CREATE_1, CREATE_0, como mostrado abaixo:
#define create(...) MACRO_CHOOSER(__VA_ARGS__)(__VA_ARGS__)
void realCreate(int x, int y)
{
printf("(%d, %d)\n", x, y);
}
#define CREATE_2(x, y) realCreate(x, y)
#define CREATE_1(x) CREATE_2(x, 0)
#define CREATE_0() CREATE_1(0)
A MACRO_CHOOSER(__VA_ARGS__)parte em última análise resolve para os nomes de definição de macro e a segunda (__VA_ARGS__)parte compreende suas listas de parâmetros. Assim, a chamada de um usuário para create(10)resolve para CREATE_1(10), a CREATE_1parte vem MACRO_CHOOSER(__VA_ARGS__)e o(10) parte vem do segundo (__VA_ARGS__).
O MACRO_CHOOSERusa o truque de que, se __VA_ARGS__estiver vazio, a seguinte expressão será concatenada em uma chamada de macro válida pelo pré-processador:
NO_ARG_EXPANDER __VA_ARGS__ () // simply shrinks to NO_ARG_EXPANDER()
Engenhosamente, podemos definir esta chamada de macro resultante como
#define NO_ARG_EXPANDER() ,,CREATE_0
Observe as duas vírgulas, elas serão explicadas em breve. A próxima macro útil é
#define MACRO_CHOOSER(...) CHOOSE_FROM_ARG_COUNT(NO_ARG_EXPANDER __VA_ARGS__ ())
então as chamadas de
create();
create(10);
create(20, 20);
são realmente expandidos para
CHOOSE_FROM_ARG_COUNT(,,CREATE_0)();
CHOOSE_FROM_ARG_COUNT(NO_ARG_EXPANDER 10 ())(10);
CHOOSE_FROM_ARG_COUNT(NO_ARG_EXPANDER 20, 20 ())(20, 20);
Como o nome da macro sugere, devemos contar o número de argumentos posteriormente. Aí vem outro truque: o pré-processador só faz uma simples substituição de texto. Ele infere o número de argumentos de uma chamada de macro apenas a partir do número de vírgulas que vê entre parênteses. Os "argumentos" reais separados por vírgulas não precisam ter sintaxe válida. Eles podem ser qualquer texto. Ou seja, no exemplo acima, NO_ARG_EXPANDER 10 ()é contado como 1 argumento para a chamada do meio. NO_ARG_EXPANDER 20e 20 ()são contados como 2 argumentos para a chamada inferior, respectivamente.
Se usarmos as seguintes macros auxiliares para expandi-los ainda mais
##define CHOOSE_FROM_ARG_COUNT(...) \
FUNC_RECOMPOSER((__VA_ARGS__, CREATE_2, CREATE_1, ))
#define FUNC_RECOMPOSER(argsWithParentheses) \
FUNC_CHOOSER argsWithParentheses
A fuga ,depois CREATE_1é uma forma de contornar GCC / CLANG, suprimindo um erro (falsos positivos) dizendo que ISO C99 requires rest arguments to be usedquando passar -pedanticpara o seu compilador. O FUNC_RECOMPOSERé uma solução alternativa para o MSVC ou não pode contar o número de argumentos (ou seja, vírgulas) entre parênteses de chamadas de macro corretamente. Os resultados são posteriormente resolvidos para
FUNC_CHOOSER (,,CREATE_0, CREATE_2, CREATE_1, )();
FUNC_CHOOSER (NO_ARG_EXPANDER 10 (), CREATE_2, CREATE_1, )(10);
FUNC_CHOOSER (NO_ARG_EXPANDER 20, 20 (), CREATE_2, CREATE_1, )(20, 20);
Como você deve ter percebido, a última e única etapa de que precisamos é empregar um truque de contagem de argumentos padrão para finalmente escolher os nomes de versão de macro desejados:
#define FUNC_CHOOSER(_f1, _f2, _f3, ...) _f3
que resolve os resultados para
CREATE_0();
CREATE_1(10);
CREATE_2(20, 20);
e certamente nos dá as chamadas de função reais desejadas:
realCreate(0, 0);
realCreate(10, 10);
realCreate(20, 20);
Juntando tudo, com algum rearranjo de declarações para melhor legibilidade, toda a fonte do exemplo de 2 argumentos está aqui:
#include <stdio.h>
void realCreate(int x, int y)
{
printf("(%d, %d)\n", x, y);
}
#define CREATE_2(x, y) realCreate(x, y)
#define CREATE_1(x) CREATE_2(x, 0)
#define CREATE_0() CREATE_1(0)
#define FUNC_CHOOSER(_f1, _f2, _f3, ...) _f3
#define FUNC_RECOMPOSER(argsWithParentheses) FUNC_CHOOSER argsWithParentheses
#define CHOOSE_FROM_ARG_COUNT(...) FUNC_RECOMPOSER((__VA_ARGS__, CREATE_2, CREATE_1, ))
#define NO_ARG_EXPANDER() ,,CREATE_0
#define MACRO_CHOOSER(...) CHOOSE_FROM_ARG_COUNT(NO_ARG_EXPANDER __VA_ARGS__ ())
#define create(...) MACRO_CHOOSER(__VA_ARGS__)(__VA_ARGS__)
int main()
{
create();
create(10);
create(20, 20);
//create(30, 30, 30); // Compilation error
return 0;
}
Embora complicado, feio, sobrecarregando o desenvolvedor de API, surge uma solução para sobrecarregar e definir parâmetros opcionais de funções C / C ++ para nós, loucos. O uso das APIs sobrecarregadas que estão chegando se tornou muito agradável e agradável. =)
Se houver qualquer outra simplificação possível dessa abordagem, por favor, me avise em
https://github.com/jason-deng/C99FunctionOverload
Mais uma vez, um agradecimento especial a todas as pessoas brilhantes que me inspiraram e levaram a concretizar este trabalho! =)