¿Es posible ordenar matrices utilizando el preprocesador?

Question

Tengo un número de matrices muy largas. No es posible ordenar en tiempo de ejecución. También lleva mucho tiempo ordenarlos manualmente. Además, se pueden agregar nuevos elementos en cualquier orden posterior, por lo que me gustaría ordenarlos por valor usando el preprocesador C o tal vez haya algún indicador de compiladores (GCC)?

Por ejemplo:

sometype S[] = { 
    {somevals, "BOB", someothervals}, 
    {somevals, "ALICE", someothervals}, 
    {somevals, "TIM", someothervals}, 
} 

, que deben seleccionarse de manera:

sometype S[] = { 
    {somevals, "ALICE", someothervals}, 
    {somevals, "BOB", someothervals}, 
    {somevals, "TIM", someothervals}, 
} 

---

RESUELTO

Ok, aquí está mi solución:

1. copiar manualmente & pegar cada matriz en un archivo temporal denominado tobesorted.c
2. Ordenar por segunda columna: sort -b -i --key=2 tobesorted.c
3. Copia & salida de pasta de nuevo en archivo original.

En realidad, sería bueno tener alguna posibilidad de llamar "ordenar" directamente desde el preprocesador (tenía la esperanza de que al menos GCC de alguna manera admite tales características, pero parece que no).

Answer 1

No, no es posible. No puede hacer operaciones de cadena (que no sean concatenación) con el preprocesador. Y tampoco puede comparar cadenas con la metaprogramación de plantillas.

[editar] Lo que podía hacer es poner su estructura de datos en un archivo que está destinado a ser procesada previamente por una escritura de la estructura externa (por ejemplo, el Unix "tipo" de servicios públicos), y luego modificar su archivo MAKE/proyecto para que en tiempo de compilación, genera un archivo C con las matrices (ordenadas) inicializadas

Answer 2

No creo que pueda hacerlo en el preprocesador gcc, nunca he visto algo que pueda hacer lo que está buscando.

Pero usted podría escribir su propia "preprocesador" en su idioma preferido scripting (Python, Perl, sed etc ...) que lo solucionaría los valores anteriores a patadas en gcc.

Answer 3

hacer esto.

1. Coloque su matriz gigante en un archivo.

2. Ordenar el archivo con la incorporada en el sort

3. escribir un pequeño programa para crear código C a partir del archivo. Un programa C que escribe programas C está bien. Puede usar Python y algunos de sus geniales paquetes de plantillas para simplificar este trabajo.

4. Compila el programa restante que consiste en el archivo ordenado transformado en código C más el resto de tu programa.

Answer 4

se me ocurre ninguna posibilidad de usar el preprocesador, pero se puede usar una combinación de sort y #include para lograr el efecto deseado:

Ponga sólo los valores en un archivo separado values.hcon el la clave de ordenación estar frente (que tendrá que reorganizar su struct sometype para esto):

{"BOB", somevals, someothervals}, 
{"ALICE", somevals, someothervals}, 
{"TIM", somevals, someothervals}, 

en su Makefile, utilice el comando Unix sort para ordenar ese archivo en values_sorted.h:

sort <values.h> values_sorted.h 

En su código real, incluya el archivo ordenado:

sometype S[] = { 
#include "values_sorted.h" 
}; 

Answer 5

Los siguientes trabajó durante dos y tres elementos:

// Experiment: static sort: 

#define STATIC_SORT2(CMP, a, b) CMP(a,b) <= 0 ?(a):(b), CMP(a,b) <= 0 ? (b):(a), 
#define STATIC_SORT3(CMP, a, b, c) \ 
    (CMP(a,b) <= 0 && CMP(a,c) <= 0 ? (a) : \ 
    CMP(b,a) <= 0 && CMP(b,c) <= 0 ? (b) : \ 
    (c)), \ 
    (CMP(a,b) <= 0 && CMP(a,c) <= 0 ? (CMP(b,c) <= 0 ? (b) : (c)) : \ 
    CMP(b,a) <= 0 && CMP(b,c) <= 0 ? (CMP(a,c) <= 0 ? (a) : (c)) : \ 
    (CMP(a,b) <= 0 ? (a) : (b))), \ 
    (CMP(a,c) <= 0 && CMP(b,c) <= 0 ? (c) : \ 
    CMP(a,b) <= 0 && CMP(c,b) <= 0 ? (b) : \ 
    (a)) 


// Example: 
// #define STATIC_INT_CMP(a,b) ((int)(a) - (int)(b)) 
// int sorted[] = { STATIC_SORT3(STATIC_INT_CMP, 2, 3, 1 } // gives { 1, 2, 3 } 
// #define STATIC_INT_COCMP(a,b) ((int)(b) - (int)(a)) 
// int cosorted[] = { STATIC_SORT3(STATIC_INT_COCMP, 2, 3, 1 } // gives { 3, 2, 1 } 

Pero Diría que está claro que este enfoque no se generaliza a matrices de tamaño arbitrario. Supongo que no es posible, pero aún no tengo una prueba formal de esta conjetura.