Variádicos macros de pré-processamento recursivo - é possível?
https://stackoverflow.com/questions/824639
-
05-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
eu correr em um pequeno problema teórico. Em um pedaço de código que estou mantendo há um conjunto de macros como
#define MAX_OF_2(a, b) (a) > (b) ? (a) : (b)
#define MAX_OF_3(a, b, c) MAX_OF_2(MAX_OF_2(a, b), c)
#define MAX_OF_4(a, b, c, d) MAX_OF_2(MAX_OF_3(a, b, c), d)
...etc up to MAX_OF_8
O que eu gostaria de fazer é substituí-los por algo como isto:
/* Base case #1, single input */
#define MAX_OF_N(x) (x)
/* Base case #2, two inputs */
#define MAX_OF_N(x, y) (x) > (y) ? (x) : (y)
/* Recursive definition, arbitrary number of inputs */
#define MAX_OF_N(x, ...) MAX_OF_N(x, MAX_OF_N(__VA_ARGS__))
... que, naturalmente, não é código pré-processador válido.
Ignorando que neste caso particular provavelmente deve ser resolvido usando uma função em vez de uma macro pré-processador , é possível definir um (macro MAX_OF_N variádica)?
Apenas para maior clareza, o resultado final deve ser um único macro que leva um número arbitrário de parâmetros e avalia a maior delas. Eu tenho uma estranha sensação de que isso deve ser possível, mas eu não estou vendo como.
Solução
Não, porque o pré-processador só tem um "golpe" no arquivo. Não há nenhuma maneira de obtê-lo para definir de forma recursiva macros.
O único código que eu vi fazer algo como isto era não variádica, mas padrão utilizados valores que o usuário tinha que passar:
x = MAX_OF_8 (a, b, -1, -1, -1, -1, -1, -1)
assumindo que todos os valores eram não-negativo.
Funções inline deve dar-lhe o mesmo para C ++, pelo menos. Como você estado, é provavelmente melhor para a esquerda para uma função com argumentos variáveis ??semelhantes a printf().
Outras dicas
É possível escrever uma macro que avalia o número de argumentos é chamado com. (Eu não poderia encontrar um link para o lugar onde eu vi pela primeira vez.) Então, você poderia escrever MAX_OF_N () que funcionaria como você gostaria, mas você ainda precisa de todas as macros numeradas até algum limite:
#define MAX_OF_1(a) (a)
#define MAX_OF_2(a,b) max(a, b)
#define MAX_OF_3(a,...) MAX_OF_2(a,MAX_OF_2(__VA_ARGS__))
#define MAX_OF_4(a,...) MAX_OF_2(a,MAX_OF_3(__VA_ARGS__))
#define MAX_OF_5(a,...) MAX_OF_2(a,MAX_OF_4(__VA_ARGS__))
...
#define MAX_OF_64(a,...) MAX_OF_2(a,MAX_OF_63(__VA_ARGS__))
// NUM_ARGS(...) evaluates to the literal number of the passed-in arguments.
#define _NUM_ARGS2(X,X64,X63,X62,X61,X60,X59,X58,X57,X56,X55,X54,X53,X52,X51,X50,X49,X48,X47,X46,X45,X44,X43,X42,X41,X40,X39,X38,X37,X36,X35,X34,X33,X32,X31,X30,X29,X28,X27,X26,X25,X24,X23,X22,X21,X20,X19,X18,X17,X16,X15,X14,X13,X12,X11,X10,X9,X8,X7,X6,X5,X4,X3,X2,X1,N,...) N
#define NUM_ARGS(...) _NUM_ARGS2(0, __VA_ARGS__ ,64,63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0)
#define _MAX_OF_N3(N, ...) MAX_OF_ ## N(__VA_ARGS__)
#define _MAX_OF_N2(N, ...) _MAX_OF_N3(N, __VA_ARGS__)
#define MAX_OF_N(...) _MAX_OF_N2(NUM_ARGS(__VA_ARGS__), __VA_ARGS__)
Agora MAX_OF_N(a,b,c,d,e) irá avaliar a max(a, max(b, max(c, max(d, e)))). (Eu testei no gcc 4.2.1.)
Note que é fundamental que o caso base (MAX_OF_2) não repetir seus argumentos mais de uma vez na expansão (que é por isso que eu coloquei max neste exemplo). Caso contrário, você estaria dobrando o comprimento da expansão para cada nível, então você pode imaginar o que vai acontecer com 64 argumentos:)
Você pode considerar esta batota, uma vez que não é recursiva e não fazer o trabalho na pré-processador. E ele usa uma extensão de GCC. E ele só funciona para um tipo. É, no entanto, uma macro MAX_OF_N aridade variável:
#include <iostream>
#include <algorithm>
#define MAX_OF_N(...) ({\
int ra[] = { __VA_ARGS__ }; \
*std::max_element(&ra[0], &ra[sizeof(ra)/sizeof(int)]); \
})
int main() {
int i = 12;
std::cout << MAX_OF_N(1,3,i,6);
}
Oh sim, e por causa do potencial de expressão variável na lista inicializador, eu não acho que um equivalente desta (utilizando a sua própria função para std :: evitar max_element) iria trabalhar em C89. Mas eu não sou macros certeza variádicos estão em C89 também.
O Aqui algo que eu acho que fica em torno da restrição "apenas um tipo". Está ficando um peludo pouco, porém:
#include <iostream>
#include <algorithm>
#define MAX_OF_N(x, ...) ({\
typeof(x) ra[] = { (x), __VA_ARGS__ }; \
*std::max_element(&ra[0], &ra[sizeof(ra)/sizeof(ra[0])]); \
})
int main() {
int i = 12;
std::cout << MAX_OF_N(i+1,1,3,6,i);
}
Eu acho que, mesmo se você poderia expandir macros de forma recursiva, haveria um pequeno problema com a sua abordagem em termos de eficiência ... quando as macros são expandidas, se o MAX_OF_[N-1] é maior, então você tem que avaliá-lo novamente a partir do zero.
Aqui está uma resposta idiota e estúpida que provavelmente ninguém vai gostar xD
arquivo "source.c"
#include "my_macros.h"
...
arquivo "Makefile"
myprogram: source.c my_macros.h
gcc source.c -o myprogram
my_macros.h: make_macros.py
python make_macros.py > my_macros.h
arquivo "make_macros.py"
def split(l):
n = len(l)
return l[:n/2], l[n/2:]
def gen_param_seq(n):
return [chr(i + ord("A")) for i in range(n)]
def make_max(a, b):
if len(a) == 1:
parta = "("+a[0]+")"
else:
parta = make_max(*split(a))
if len(b) == 1:
partb = "("+b[0]+")"
else:
partb = make_max(*split(b))
return "("+parta +">"+partb+"?"+parta+":"+partb+")"
for i in range(2, 9):
p = gen_param_seq(i)
print "#define MAX_"+str(i)+"("+", ".join(p)+") "+make_max(*split(p))
então você vai ter essas macros bonitas definido:
#define MAX_2(A, B) ((A)>(B)?(A):(B))
#define MAX_3(A, B, C) ((A)>((B)>(C)?(B):(C))?(A):((B)>(C)?(B):(C)))
#define MAX_4(A, B, C, D) (((A)>(B)?(A):(B))>((C)>(D)?(C):(D))?((A)>(B)?(A):(B)):((C)>(D)?(C):(D)))
#define MAX_5(A, B, C, D, E) (((A)>(B)?(A):(B))>((C)>((D)>(E)?(D):(E))?(C):((D)>(E)?(D):(E)))?((A)>(B)?(A):(B)):((C)>((D)>(E)?(D):(E))?(C):((D)>(E)?(D):(E))))
#define MAX_6(A, B, C, D, E, F) (((A)>((B)>(C)?(B):(C))?(A):((B)>(C)?(B):(C)))>((D)>((E)>(F)?(E):(F))?(D):((E)>(F)?(E):(F)))?((A)>((B)>(C)?(B):(C))?(A):((B)>(C)?(B):(C))):((D)>((E)>(F)?(E):(F))?(D):((E)>(F)?(E):(F))))
#define MAX_7(A, B, C, D, E, F, G) (((A)>((B)>(C)?(B):(C))?(A):((B)>(C)?(B):(C)))>(((D)>(E)?(D):(E))>((F)>(G)?(F):(G))?((D)>(E)?(D):(E)):((F)>(G)?(F):(G)))?((A)>((B)>(C)?(B):(C))?(A):((B)>(C)?(B):(C))):(((D)>(E)?(D):(E))>((F)>(G)?(F):(G))?((D)>(E)?(D):(E)):((F)>(G)?(F):(G))))
#define MAX_8(A, B, C, D, E, F, G, H) ((((A)>(B)?(A):(B))>((C)>(D)?(C):(D))?((A)>(B)?(A):(B)):((C)>(D)?(C):(D)))>(((E)>(F)?(E):(F))>((G)>(H)?(G):(H))?((E)>(F)?(E):(F)):((G)>(H)?(G):(H)))?(((A)>(B)?(A):(B))>((C)>(D)?(C):(D))?((A)>(B)?(A):(B)):((C)>(D)?(C):(D))):(((E)>(F)?(E):(F))>((G)>(H)?(G):(H))?((E)>(F)?(E):(F)):((G)>(H)?(G):(H))))
e a melhor coisa sobre ele é que ... ele funciona ^ _ ^
Se você estiver indo por este caminho em C ++, dê uma olhada template metaprogramming . Não é bonito, e pode não resolver o seu problema exato, mas ele vai lidar com recursão.
Em primeiro lugar, macros não expandir recusrsively. Embora, as macros podem ter reentrance criando uma macro para cada nível de recursão e depois deduzir o nível de recursão. No entanto, tudo isso repetição e deduzir recursão, é cuidado pela biblioteca Boost.Preprocessor . portanto, você pode usar a ordem superior dobrar macro para calcular o máx:
#define MAX_EACH(s, x, y) BOOST_PP_IF(BOOST_PP_GREATER_EQUAL(x, y), x, y)
#define MAX(...) BOOST_PP_SEQ_FOLD_LEFT(MAX_EACH, 0, BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__))
MAX(3, 6, 8) //Outputs 8
MAX(4, 5, 9, 2) //Outputs 9
Agora, isso vai entender números literais entre 0-256. Não vai trabalhar em variáveis ??ou expressão C ++, porque o pré-processador C não entende C ++. A sua substituição apenas texto puro. Mas C ++ fornece um recurso chamado de "função" que irá funcionar em expressões C ++, e você pode usá-lo para calcular o valor máximo.
template<class T>
T max(T x, T y)
{
return x > y ? x : y;
}
template<class X, class... T>
auto max(X x, T ... args) -> decltype(max(x, max(args...)))
{
return max(x, max(args...));
}
Agora, o código acima requer um C ++ 11 compilador. Se você estiver usando C ++ 03, você pode criar várias sobrecargas da função, a fim de simular parâmetros variádicos. Além disso, podemos usar o pré-processador para gerar este código repetitivo para nós (isso é o que ele está lá para). Assim, em C ++ 03, você pode escrever o seguinte:
template<class T>
T max(T x, T y)
{
return x > y ? x : y;
}
#define MAX_FUNCTION(z, n, data) \
template<class T> \
T max(T x, BOOST_PP_ENUM_PARAMS(n, T x)) \
{ \
return max(x, max(BOOST_PP_ENUM_PARAMS(n, x)));\
}
BOOST_PP_REPEAT_FROM_TO(2, 64, MAX_FUNCTION, ~)
