SITO WEB: www.sys14.it

 

 

Studiando il capitolo: "Il processore" nel libro "programmazione in C" mi è venuta in mente l'idea di scrivere una documentazione riguardante le direttive del processore in C (visto che nel web non ce ne sono molte DETTAGLIATE).

Le direttive del preprocessore si possono dividere in tre categorie:

  • Definizioni di macro
  • Inclusioni di file
  • Compilazione condizionale


Incominciamo con la prima:

  • Definizioni di macro

Le definizioni di macro vengono impiegate con la seguente riga di codice:

Codice:
#define STAMPA_NEW_LINE printf("\n\n")

adesso per ogni chiamata STAMPA_NEW_LINE; il programma fa riferimento alla funzione: printf("\n\n"); Da notare che nelle definizioni di macro non si mette mai il ; inoltre la direttiva #define è preferibile  essere inserita prima della funzione main. L'ultima macro per la categoria: Definizioni di macro è la direttiva #undef La direttiva #undef rimuove la definizioni di una macro. Guardiamo questo programma:

Codice:
#include <stdio.h>
#define STAMPA_NEW_LINE printf("\n\n")

int main (void) {
	STAMPA_NEW_LINE; /* esegue la chiamata */ 
	#undef STAMPA_NEW_LINE /* rimuove la definizione */
	STAMPA_NEW_LINE; /* errore, la definizione è stata rimossa */ 
        getchar();
	return 0;
}

Queste sono le definizioni di macro.
Passiamo alla seconda categoria.

  • Inclusione di file

Come suggerisce il nome della categoria si immagina l'inclusione di un file all'interno di un programma. Ebbene si. La direttiva è:

Codice:
#include <stdio.h>

Queste direttive devono essere per forza all'inizio di un programma. In questo caso abbiamo incluso la libreria stridio.h che serve per l'input / output ecc ...
Passiamo all'ultima categoria. La più divertente.

  • Compilazione condizionale

Comprendono le direttive:

Codice:
#if, #ifdef, #ifndef, #elif, #else, #endif (tutte queste macro possono essere inesrite sia all'interno della funziona main p anche all'inizio del code. Sotto la direttiva inlcude <stdio.h> per intenderci)

Queste ultime servono ad includere, escludere alcune parti di codice in base ad alcuni eventi.

#if
Incominciamo con un bel esempio

Codice:
#include <stdio.h>
#define VERO 1

int main (void) {
	 #if VERO
	 printf("Vero == 1\n");
	 #endif
         getchar();
	 return 0;
 }

Se priviamo ad compilare ed eseguire il programma uscirà il seguente output:

Codice:
pitagora@pitagora:~$ gcc if.c -o if
pitagora@pitagora:~$ ./if
Vero == 1

#if eseguirà le istruzioni soltanto se la macro precedentemente dichiarata ha il valore di 1 (vero). Se il valore è uguale a 0 allora non eseguirà le istruzioni. Si potrebbero confrontare con i valore booleani:

  • 1 == vero
  • 0 == falso

Questo programma può essere tradotto nel seguente formato:

Codice:
#include <stdio.h>
#define VERO 1

int main (void) {
	 if (VERO == 1) {
		 printf("Vero == 1\n");
	 }
	 return 0;
 }

Adesso vi starete chiedendo, e #endif cos'è ? È facile, la macro #if è seguita sempre dalla macro #endif è come se stessimo dicendo al programma che l'if è finito. Si potrebbero confrontare con questa { /* apertura */ e } /* chiusura */
Come penultime macro abbiamo: #ifdef e #ifndef

Codice:
#ifdef nome_identificatore

Fa l'opposto di #ifndef. #ifdef controlla se il nome_identificato è stato definisto come una macro. Se si, esegue le istruzioni altrimenti: si passa avanti. #ifndef invece controlla se il nome_identificatore è presente, è stato dichiarato.
infine abbiamo #elif e #else
Un esempio è questo:

Codice:
#include <stdio.h>
#define ESISTE

int main (void) {
	#if WIN32 /* se il valore ritorna 1 (vero) */
	printf("O.S. = windows 32 bit \n\n");
	#elif MAC_OS /* se il valore ritorna 1 (vero) */
	printf("O.S. = Mac_Os \n\n");
	#else /* se non è nessuna delle condizioni in precedenza */[code]
	printf("O.S. = Linux \n\n");
	#endif

	getchar();
	return 0;
}


Infine abbiamo #error, #line. La macro

Codice:
#error messaggio

produce un errore del tipo: Error directive: messaggio ....

Codice:
#line n

dove n è un intero è corrisponde al numero di riga da quale si vuole fare partire esempio:

Codice:
#include <stdio.h>

int main (void) {
	#line 122
	funzione_non_definita;
	return 0;
}

Notate l'errore:

Codice:
pitagora@pitagora:~$ gcc processore.c -o processore
processore.c: In function main:
processore.c:122: error: funzione_non_definita undeclared (first use in this function)
processore.c:122: error: (Each undeclared identifier is reported only once
processore.c:122: error: for each function it appears in.)
processore.c:123: error: expected ; before return

Notate la riga .... È possibile che questo programma ha 122 righe ?  bha !