Ho visto diversi macro per la lunghezza dell’array fluttuante: Da questa domanda : #define length(array) (sizeof(array)/sizeof(*(array))) #define ARRAY_LENGTH(array) (sizeof((array))/sizeof((array)[0])) #define SIZE(array, type) (sizeof(array) / (sizeof(type)) E il _countof : #define _countof(_Array) (sizeof(_Array) / sizeof(_Array[0])) Quello che mi piacerebbe sapere è: Qual è la differenza tra quelli che usano array[0] e *array ? Perché dovrebbe essere […]
Mi chiedo quanto siano diversi i preprocessori per C ++ e C. La ragione della domanda è questa domanda su una domanda specifica del preprocessore in cui il paragrafo dello standard che indirizza la domanda ha una formulazione diversa (e un numero di paragrafo diverso) e anche la differenza riguardante le parole chiave true e […]
Voglio scrivere una macro che sputa il codice in base al valore booleano del suo parametro. Pertanto, DEF_CONST(true) deve essere espanso in const e DEF_CONST(false) deve essere espanso in nulla. Chiaramente quanto segue non funziona perché non possiamo usare un altro preprocessore all’interno di #defines: #define DEF_CONST(b_const) \ #if (b_const) \ const \ #endif
#include #define f(a,b) a##b #define g(a) #a #define h(a) g(a) int main() { printf(“%s\n”,h(f(1,2))); printf(“%s\n”,g(f(1,2))); return 0; } Solo guardando il programma uno “potrebbe” aspettarsi che l’output sia, lo stesso per entrambe le affermazioni printf. Ma durante l’esecuzione del programma si ottiene come: bash$ ./a.out 12 f(1,2) bash$ Perché è così?
Sto iniziando a programmare in Java e mi chiedo se esiste l’equivalente del #define C ++. Una rapida ricerca su google dice che non è così, ma qualcuno potrebbe dirmi se qualcosa di simile esiste in Java? Sto cercando di rendere il mio codice più leggibile. Invece di myArray[0] voglio essere in grado di scrivere […]
Ci sono simboli di preprocessore che permettono qualcosa di simile #if CLR_AT_LEAST_3.5 // use ReaderWriterLockSlim #else // use ReaderWriterLock #endif o qualche altro modo per farlo?
Ho un programma in C : #define f(g,g2) g##g2 main() { int var12=100; printf(“%d”,f(var,12)); } quando eseguo solo il preprocessore espande questo come { int var12=100; printf(“%d”,var12); } qual è il motivo per cui l’output è 100. Qualcuno può dirmi come / perché il preprocessore espande var##12 to var12 ?
Il mio preprocessore sembra assumere che le costanti non definite siano 0 allo scopo di valutare le condizioni di #if . Si può fare affidamento su questo o le costanti non definite danno un comportamento indefinito?
Sto usando una libreria open source che sembra avere molte direttive di pre-elaborazione per supportare molte lingue diverse da C. Per poter studiare cosa sta facendo la libreria mi piacerebbe vedere il codice C che sto compilando dopo la pre-elaborazione , più come quello che scriverei. Gcc (o qualsiasi altro strumento comunemente disponibile in Linux) […]
Ad esempio, come evitare di scrivere il “nome_completo” due volte? #ifndef TEST_FUN # define TEST_FUN func_name # define TEST_FUN_NAME “func_name” #endif Mi piacerebbe seguire la regola Single Point of Truth . Versione del preprocessore C: $ cpp –version cpp (GCC) 4.1.2 20070626 (Red Hat 4.1.2-14)