01. Caratteristiche del linguaggio C 
02. Storia del linguaggio C 
03. Primo approccio 
04. Compilazione di un programma C 
05. Struttura di un programma C 
06. Variabili 
	06.01. Stampa ed input di variabili 
07. Operatori 
	07.01. Operatori aritmetici 
	07.02. Operatori di confronto 
	07.03. Operatori logici 
	07.04. Operatori di basso livello 
		07.04.01. Operatori di bitwise 
		07.04.02. Bit Fields 
	07.05. Ordine di precedenza degli operatori 
08. Strutture di controllo 
	08.01. If 
	08.02. Operatore "?" 
	08.03. Switch 
	08.04. For 
	08.05. While 
	08.06. Do-While 
	08.07. Break e Continue 
09. Arrays 
	09.01. Array singoli e multidimensionali 
	09.02. Stringhe 
10. Funzioni 
	10.01. Funzioni "void" 
	10.02. Funzioni ed array 
	10.03. Prototipi di funzioni 
11. Ulteriori tipi di dati 
	11.01. Strutture 
	11.02. Unioni 
	11.03. Type-casting 
	11.04. Enumerated Types 
	11.05. Variabili statiche 
12. Errori comuni in C 
	12.01. Assegnazione (=) al posto di confronto (==) 
	12.02. Passaggio dell'indirizzo di puntatori 
	12.03. Mancanza di () per una funzione 
	12.04. Indici di array 
	12.05. Array di caratteri e puntatori 
	12.06. C e' case-sensitive 
	12.07. ";" chiude ogni istruzione 
13. Puntatori 
	13.01. Cos'e' un puntatore 
	13.02. Puntatori e funzioni 
	13.03. Puntatori e array 
	13.04. Array di puntatori 
	13.05. Array multidimensionali e puntatori 
	13.06. Inizializzazione statica degli array di puntatori 
	13.07. Puntatori e strutture 
	13.08. Le "trappole" piu' comuni dei puntatori 
		13.08.01. Non assegnare un puntatore ad un indirizzo di 
			  memoria prima di utilizzarlo 
		13.08.02. Assegnazione indiretta illegale 
14. Allocazione dinamica della memoria 
	14.01. Malloc 
	14.02. Linked Lists 
15. Input ed output 
	15.01. Streams 
		15.01.01. Streams predefinite 
			15.01.01.01. Redirezione 
	15.02. Funzioni comuni di I/O 
	15.03. Formattazione di I/O 
		15.03.01. Printf 
	15.04. Scanf 
	15.05. Files
		15.05.01. Lettura e scrittura su files 
	15.06. Sprintf ed Sscanf 
	15.07. Input dalla linea di comando 
	15.08. I/O di basso livello 
16. Il preprocessore C 
	16.01. #define 
	16.02. #undef 
	16.03. #include 
	16.04. #if - Inclusione condizionale 
17. Scrittura di grossi programmi 
	17.01. File header 
	17.02. Variabili esterne e funzioni 
		17.02.01. Scopo delle variabili esterne 
	17.03. L'utility Make 
	17.04. Programmazione di Make 
	17.05. Creazione di un makefile 
	17.06. Macro di Make 
	17.07. Esecuzione di Make 
18. UNIX e il C 
	18.01. Vantaggi di usare UNIX con il C 
	18.02. Utilizzo delle chiamate di sistema UNIX e delle funzioni 
	       di libreria 
	18.03. Trattamento di file e directory 
		18.03.01. Funzioni di trattamento delle directory 
		18.03.02. Routine di trattamento dei file 
		18.03.03. errno 
	18.04. Controllo e gestione dei processi 
		18.04.01. Esecuzione di comandi UNIX da C 
			18.04.01.01. execl() 
			18.04.01.02. fork() 
			18.04.01.03. wait()
			18.04.01.04. exit() 
		18.04.02. Utilizzo di pipe in un programma C 
			18.04.02.01. popen() - Piping formattato 
			18.04.02.02. pipe() - Piping di basso livello 
		18.04.03. Interruzioni e segnali 
			18.04.03.01. Invio di segnali - kill() 
			18.04.03.02. Ricezione di segnali - signal() 
	18.05. Times Up!! 
19. Opzioni comuni del compilatore C 
	19.01. Opzioni di compilazione 
20. Funzioni della libreria standard C 
	20.01. Manipolazione dei buffer 
	20.02. Classificazione dei caratteri e conversione 
	20.03. Conversione dei dati 
	20.04. Manipolazione delle directory 
	20.05. Manipolazione dei file 
	20.06. Input e Output 
		20.06.01. Stream I/O 
		20.06.02. I/O di basso livello 
	20.07. Matematica 
	20.08. Allocazione di memoria 
	20.09. Controllo dei processi 
	20.10. Ricerca e ordinamento 
	20.11. Manipolazione di stringhe 
	20.12. Time 

==============================================================================

------------------------------------------------------------------------------
01. Caratteristiche del linguaggio C 
------------------------------------------------------------------------------

  Qui di seguito verranno elencate brevemente alcune delle caratteristiche del
  C che definiscono il linguaggio stesso e che hanno contribuito alla 
  popolarita' che ha raggiunto come linguaggio di programmazione:

  - dimensioni ridotte
  - utilizzo frequente di chiamate a funzioni
  - loose typing (a differenza del Pascal)
  - linguaggio strutturato
  - programmazione a basso livello facilmente disponibile
  - implementazione dei puntatori (ampio uso di puntatori per memoria, 
    vettori, strutture e funzioni)

  Il C e' ora diventato un linguaggio professionale ampiamente utilizzato per
  varie ragioni:

  - ha strutture di alto livello
  - puo' maneggiare attivita' di basso livello
  - produce programmi efficienti
  - puo' essere compilato su un'ampia gamma di computers

  Il suo principale inconveniente e' quello di avere un metodo scadente per
  l'identificazione di errori, che puo' escluderne l'utilizzo ai principianti. 
  Comunque con un minimo di diligenza si puo' risolvere elegantemente questo 
  problema, in quanto si possono violare le regole del C non appena si sono 
  imparate (non molti linguaggi lo permettono). Nel caso in cui venga fatto 
  correttamente e con attenzione, questo porta a sfruttare le potenzialita'
  della programmazione C.
  Lo standard per i programmi C in origine era dato dalle caratteristiche 
  messe a punto da Brian Kernighan. Al fine di rendere il linguaggio piu' 
  accettabile a livello internazionale, venne messo a punto uno standard 
  internazionale chiamato ANSI C (American National Standards Institute).

------------------------------------------------------------------------------
02. Storia del linguaggio C 
------------------------------------------------------------------------------

  Le pietre miliari nel corso dell'evoluzione del C come linguaggio sono 
  elencate di seguito:

  - UNIX developed c. 1969 - DEC PDP-7 Assembly Language
  - BCPL - un OS facilmente accessibile che fornisce potenti strumenti di 
    sviluppo prodotti a partire da BCPL. Si tratta di un assemblatore noioso, 
    lungo ed incline agli errori
  - Un nuovo linguaggio "B" come secondo tentativo c. 1970
  - Un linguaggio "C" totalmente nuovo come successore di "B" c. 1971
  - Dal 1973 UNIX OS, quasi totalmente scritto in C 

------------------------------------------------------------------------------
03. Primo approccio 
------------------------------------------------------------------------------

  Un minimo programma in C e':

	main()
	  {
 
	  }

  che corrisponde a un programma in Pascal:

	program minimum;

	begin

	end

  Ogni programma C deve contenere una e una sola funzione main().
  Per ogni parentesi graffa aperta (che corrisponde al begin in pascal)
  deve essercene una chiusa (che corrisponde all'end in pascal).

  I commenti possono essere posti ovunque utilizzando /* (inizio commento)
  e */ (fine commento), ma non si puo' inserire un commento in un altro. 
  Ad esempio:

	/* Esempio di programma in C */
	main()
	  {
	    /* Un ulteriore commento */               ESATTO 
	    /* Commento /* Ancora un commento */ */   ERRATO 
	  }

  Il seguente esempio e' un programma che produce l'output sullo
  schermo della frase "Hello World":

        main()
          {
	    printf("Hello World n");
	    exit(0);
          }

  L'istruzione "printf" e' una funzione C che visualizza cio' che gli
  viene passato come argomento.

  Per creare un file contenente uno dei precedenti programmi si puo'
  utilizzare un qualsiasi text editor disponibile sulla macchina (vi, emacs,
  xedit, ...).
  Il nome del file deve avere l'estensione ".c", cioe' chiamarsi, ad esempio, 
  prog.c. Il contenuto, ovviamente, deve rispettare la sintassi C; per quanto 
  riguarda gli esempi sopra riportati, potrebbero iniziare con una riga del
  tipo
     /* Esempio ... */          (anche con una linea vuota che la precede)
  e terminare con la linea
     } /* Fine del programma */ (anche con una linea vuota che la segue)

------------------------------------------------------------------------------
04. Compilazione di un programma C 
------------------------------------------------------------------------------

  Per compilare il programma si utilizza il comando cc seguito dal nome del
  programma C sorgente, dove "cc" e' il nome del compilatore C. 
  Ad esempio:
		cc prog.c

  Se il compilatore trova errori (in genere syntax error, come errori di 
  battitura, errori di sintassi delle parole chiave o ";" omessi), questi 
  vengono identificati e visualizzati; in caso contrario, viene creato il 
  file eseguibile a.out. Il compilatore non identifica eventuali errori di
  logica del programma, quindi potrebbero essere eseguite delle operazioni
  errate, ed e' compito dell'utente trovarle (anche con l'ausilio di appositi
  programmi di debugging).
  In fase di compilazione possono essere specificate anche ulteriori opzioni: 
  la piu' utilizzata e' "-o nome-file", che crea l'eseguibile con il nome 
  nome-file invece di a.out, ma ne esistono altre come ad esempio "-c" 
  (opzione senza argomenti, per la soppressione di link).
  Altra opzione possibile e' "-g", con cui e' necessario compilare per poter 
  utilizzare il debugger "dbx".
  Ad esempio:	
		cc prog.c -o prog (oppure cc -o prog.c prog)
		cc -c prog.c -o prog
		cc -g prog.c -o prog

  Per far eseguire il programma e' sufficiente scrivere il nome 
  dell'eseguibile creato (e' ovvio che il file eseguibile deve avere i 
  permessi per l'esecuzione, solitamente assegnati automaticamente in fase di
  compilazione):
  si avranno visualizzati sullo schermo gli eventuali risultati.
  Nel momento dell'esecuzione e' possibile osservare ed identificare eventuali
  errori di run-time, come ad esempio le divisioni per zero; in tal caso 
  l'esecuzione termina irregolarmente e viene generato un file core con lo
  stato del programma in esecuzione al momento del verificarsi dell'errore.
  Se il programma in esecuzione non rilascia errori ma produce output errati, 
  e' evidente che contiene errori logici; questi andranno corretti editando 
  il programma sorgente, questo dovra' essere ricompilato e si potra' lanciare
  nuovamente l'esecuzione.

  La compilazione del programma C avviene attraverso le seguenti fasi:

   - un preprocessore che accetta il codice sorgente come input 
     ed e' resposabile della: 

  	 - rimozione di commenti 
   	 - interpretazione di speciali direttive per il preprocessore 
	   denotate da "#". 
    	   Ad esempio: 
		#include - include il contenuto di un determinato file
                           (solitamente chiamato header, con suffisso ".h").
        		 #include  - standard library maths file. 
         		 #include  - standard library I/O file 
		#define  - definisce un nome simbolico o una costante
			   (sostituzione di una macro).
            		 #define MAX_ARRAY_SIZE 100 

   - il compilatore C che traduce il codice sorgente ricevuto dal 
     preprocessore in codice assembly.

   - l' assembler che crea il codice oggetto (in UNIX i file con il suffisso
     .o sono i file in codice oggetto, che corrispondono ai file .obj in 
     MSDOS).

   - il link editor che combina le funzioni definite in altri file sorgenti 
     o definite in librerie, con la funzione main() per creare il file 
     eseguibile.
     Infatti molte delle funzioni presenti in altri linguaggi non sono incluse
     nel C (ad esempio, funzioni di I/O, di manipolazione di stringhe o 
     matematiche), ma il C fornisce tali funzionalita' attraverso un ricco 
     insieme di librerie di funzioni. Molte applicazioni C includono librerie
     standard di funzioni per coprire le utilita' mancanti. 
     In questa fase vengono anche ricostruiti i riferimenti alle variabili
     esterne utilizzate nei sorgenti C.

------------------------------------------------------------------------------
05. Struttura di un programma C 
------------------------------------------------------------------------------

  Un programma C ha in linea di principio la seguente forma:

	Comandi per il preprocessore
	Definizione di tipi
	Prototipi di funzioni (dichiarazione dei tipi delle funzioni e delle
                               variabili passate alle funzioni)
	Variabili
	Funzioni	
    
  Vediamo l'esempio di un programma:
    
    	main()
         {
           printf("I like Cn");
           exit(0);
         }  
   
  Note:
     - Il C richiede un punto e virgola alla fine di ogni statement.
     - printf() e' una funzione standard richiamata da main.
     - n significa una nuova linea (a capo).
     - exit() e' anch'essa una funzione standard che fa terminare il programma 
       (qui non sarebbe necessaria in quanto e' l'ultima linea di main e il 
       programma terminerebbe comunque).

------------------------------------------------------------------------------
06. Variabili 
------------------------------------------------------------------------------

  Il C ha i seguenti tipi di dati:
       
        Tipo			Size (byte)
	        
        char				1	
        unsigned char			1
        short int			2
        unsigned short int		2
        (long) int 			4
        float				4
        double				8
 
  Sui sistemi UNIX tutte le variabili dichiarate "int" sono considerate
  "long int", mentre "short int" deve essere dichiarato esplicitamente. 
  E' importante notare che in C non esiste un tipo di variabile booleano,
  quindi si possono utilizzare variabili "char", "int" o meglio "unsigned
  char". "unsigned" puo' essere utilizzato con tutti i tipi "char" e "int".

  Per dichiarare una varibile si scrive:
	 var_tipo elenco-variabili-separate-da-virgole ;
 
  Le variabili globali si definiscono al di sopra della funzione main(),
  nel seguente modo:

	short number,sum;
	int bignumber,bigsum;
	char letter;
	main()
	{
	...
	}

  E' possibile preinizializzare una variabile utilizzando = (operatore di 
  assegnazione).	
  Ad esempio:	
	int i,j,k=1;
	float x=2.6,y;
	char a;

  Vediamo due esempi di inizializzazione di variabili che si equivalgono,
  senza pero dimenticare che il metodo utilizzato nel primo esempio 
  risulta piu' efficiente:

  Esempio 1:     float sum=0.0;
		 int bigsum=0;
		 char letter='A';
		 main()
		 {
		 ...
		 }
  Esempio2:      float sum;
		 int bigsum;
		 char letter;
		 main()
		 {
		 sum=0.0;
		 bigsum=0;
		 letter='A';
		 ...
		 }
		 	
  E' possibile effettuare assegnazioni multiple purche' le variabili
  siano dello stesso tipo.	  	
  Ad esempio:
  
 	int somma;
 	char letter="A";			
	main()
	  { 
	    int a,b,c=3;
	    a=b=c;
	  }
  dove l'istruzione a=b=c (con c=3) corrisponde ad a=3, b=3 e c=3, ma
  anche in questo caso risulta piu' efficiente il primo metodo.
 
  Si possono definire nuovi propri tipi di variabili utilizzando "typedef"
  (questo risulta utile quando si creano strutture complesse di dati).
  Come esempio di utilizzo semplice consideriamo come sia possibile creare
  i due nuovi tipi di variabile "real" e "letter", che potranno successiva-
  mente essere utilizzati alla stessa maniera dei tipi predefiniti del C.
  Ad esempio:
 	 typedef float real;
 	 typedef char letter;
      variabili dichiarate:
 	 real sum=0.0;	  
	 letter nextletter;

------------------------------------------------------------------------------
06.01. Stampa ed input di variabili 
------------------------------------------------------------------------------

  Il C sfrutta l'output formattato.

  Per stampare il contenuto di una variabile si utilizza la funzione printf().
  Bisogna pero' specificare il formato della variabile utilizzando il 
  carattere speciale di formattazione "%" seguito dal carattere che definisce 
  un certo formato per una variabile:
  
 	 %c  - char
 	 %d  - int
 	 %f  - float
  	
  Ad esempio:	printf("%c%d%f",letter,somma,z);	

  Nota: l'istruzione di formattazione e' racchiusa tra "", e le variabili 
        vengono esposte di seguito; assicurarsi che l'ordine dei formati ed
        il tipo di dato delle variabili coincidano.

  Sempre a proposito della funzione "printf", vediamo il seguente esempio di
  una istruzione di stampa:

	printf(".n.1n..2n...3n");

  per la quale l'output sara': 

	.
	.1
	..2
	...3
 
  scanf() e' la funzione per l'input di valori a strutture di dati.
  Il suo formato e' simile a quello di printf():
   
      scanf("%c%d%f",&ch,&i,&x);  

  Nota: "&" si riferisce all'indirizzo della variabile, e va sempre messo 
	davanti ai nomi di variabili in acquisizione; il motivo verra' 
	spiegato nel paragrafo dei "puntatori".

------------------------------------------------------------------------------
07. Operatori 
------------------------------------------------------------------------------
 
------------------------------------------------------------------------------
07.01. Operatori aritmetici 
------------------------------------------------------------------------------

  Come gia' accennato, le assegnazioni in C vengono effettuate utilizzando 
  "=".  Oltre agli operatori arimetici standard +,-,*,/  e all'operatore % 
  (modulo) per gli interi, in C si hanno anche gli operatori incremento ++ 
  e decremento --, che possono essere preposti o posposti all'argomento. Se 
  sono preposti il valore e' calcolato prima che l'espessione sia valutata, 
  mentre se sono posposti il valore viene calcolato dopo la valutazione della 
  espressione.
  Ad esempio:
     		  int x,z=2;    
      	 1)	  x=(++z)-1; 
			 A questo punto x=2 e z=3
       
      		  int x,z=2;    
       	 2)	  x=(z++)-1; 
			 A questo punto x=1 e z=3

  Riportiamo un ulteriore esempio:
	int x,y,w;
	main()
	{
	x=((++z)-(w--))%100;
	}
  che equivale alle seguenti istruzioni:
	int x,y,w;
	main()
	{
	z++;
	x=(z-w)%100;
	w--;
	}
		 	
  E' importante sottolineare che un'istruzione del tipo
	x++
  e' piu' veloce della corrispondente
	x=x+1

  L'operatore "%" (modulo) puo' essere utilizzato solamente con le variabili
  di tipo integer; la divisione "/" e' utilizzata sia per gli integer che
  per i float.
  A proposito della divisione riportiamo un altro esempio:
	z=3/2
     dove z avra' valore 1, anche se e' stato dichiarato come float
     (di regola, se entrambi gli argomenti della divisione sono integer,
     allora verra' effettuata una divisione integer);
     per avere un risultato corretto sara' necessario scrivere:
	z=3.0/2     oppure 
	z=3/2.0     o, ancora meglio,
	z=3.0/2.0	

  Inoltre esiste una forma contratta per espressioni del tipo
   
	expr1 = expr1 op expr2
   
  (ad esempio: i=i+2 oppure x=x*(y+3))
  che diventano:

	expr1 op = expr2
   
  Per cui i=i+2 puo' essere scritta nel modo contratto come i+=2 
  od x=x*(y+3) diventare x*=y+3.

  Nota: l'espressione x*=y+3 corrisponde a x=x*(y+3) e non a x=x*y+3.

------------------------------------------------------------------------------
07.02. Operatori di confronto 
------------------------------------------------------------------------------

  Per testare l'ugualianza si usa "==" mentre per la disugualianza "!=".
  Ci sono poi gli operatori "<" (minore), ">" (maggiore), "<=" (minore o 
  uguale), ">=" (maggiore o uguale).
 
  NB. if (i==j) ... esegue il contenuto dell'if se i e' uguale a j, ma
      if (i=j) ... e' ancora sintatticamente esatto ma effettua l'assegnazione
      del valore di j ad i e procede se j e' diverso da zero in quanto
      viene interpretato il valore TRUE (e' come scrivere if i ... con i
      diverso da zero). In questo caso si tratterebbe di una "assegnazione di
      valore", una caratteristica chiave del C.

------------------------------------------------------------------------------
07.03. Operatori logici 
------------------------------------------------------------------------------

  Gli operatori logici, solitamente utilizzati con le istruzioni condizionali
  che vedremo piu' avanti, sono "&&" per AND logico  e "||" per OR logico.
  Nota: "&" e "|" hanno un significato diverso, poiche' sono bitwise AND e OR. 

------------------------------------------------------------------------------
07.04. Operatori di basso livello 
------------------------------------------------------------------------------

  Nel capitolo relativo ai puntatori si vedra' come questi permettano il 
  controllo delle operazioni di memoria di basso livello.

  Molti programmi (in particolare le applicazioni di gestione del sistema) 
  devono realmente operare a basso livello, poiche' lavorano su bytes 
  individuali.

  E' importante notare che la combinazione di puntatori e di operatori
  bit-level rendono il C utilizzabile per molte applicazioni a basso livello
  e possono quasi sempre sostituire il codice assembly (ricordiamo che 
  solamente circa il 10% di UNIX e' un codice assembly, mentre il resto e' C).

------------------------------------------------------------------------------
07.04.01. Operatori di bitwise 
------------------------------------------------------------------------------

  Gli operatori di bitwise (che operano sui singoli bit) sono i seguenti:
   "&" AND
   "|" OR
   "^" XOR
   "~" Complemento a 1 (0=>1, 1=>0)
   "<<" shift a sinistra
   ">>" shift a destra  
     
  Nota:	fare attenzione, come gia' detto in precedenza, a non confondere
        & con && (& e' "bitwise and", mentre && e' "logical and"); la stessa
	cosa vale per | e ||.

  "~" e' un operatore unario, cioe' opera su un solo argomento indicato a
  destra dell'operatore.

  Gli operatori di shift eseguono un appropriato shift dall'operatore indicato 
  a destra a quello indicato a sinistra. L'operatore destro deve essere 
  positivo. I bits liberati vengono riempiti con zero (cioe' non si tratta di
  una rotazione, con recupero sul lato opposto dei bit shiftati).

  Ad esempio: z<<2 shifta i bit in z di due posti verso sinistra
	      cosi',         se z=00000010 (binario) o 2 (decimale)
	      allora,  z>>=2 => z=00000000 (binario) o 0 (decimale)
	      inoltre, z<<=2 => z=00001000 (binario) o 8 (decimale)    

  Quindi, uno shift a sinistra e' equivalente ad una moltiplicazione per 2;
  similmente, uno shift a destra equivale ad una divisione per 2.  

  Nota: l'operazione di shift e' molto piu' veloce della reale moltiplicazione
	(*) o divisione (/); cosi', se occorrono veloci moltiplicazioni o 
        divisioni per 2 si puo' utilizzare lo shift. 

  Per illustrare le molteplici caratteristiche degli operatori di bitwise,
  riportiamo una funzione (bitcount) che somma 2 bit settati ad 1 un un numero 
  ad 8 bit (unsigned char) passato come argomento alla funzione:

      int bitcount(unsigned char x)

	    {int count;
	     for (count=0; x!=0; x>>=1);
	         if (x&01)
		    count++;
	     return count;
	    } 

  Questa funzione mostra molti punti del programma C:
	- il loop "for" non viene usato per semplici operazioni di somma
	- x>>=1 => x=x>>1
	- il loop "for" shifta ripetutamente a destra x, finche' x diventa 0
	- il controllo "if" utilizza la valutazione dell'espressione x &01
	- x &01 controlla il primo bit di x, ed esegue count++ se questo e' 1

------------------------------------------------------------------------------
07.04.02. Bit Fields 
------------------------------------------------------------------------------

  I Bit Fields permettono il raggruppamento dei dati in una struttura. Questa
  tecnica viene usata soprattutto quando la gestione della memoria o la 
  memorizzazione dei dati sono uno meta molto ambita.

  Tipici esempi sono costituiti da:

  - raggruppamento di parecchi oggetti in una parola macchinai (i flag di un 
    bit possono essere compattati); ad esempio, la tabella dei simboli 
    nell'ambito dei compilatori;
  - lettura di formati di file esterni (formati di file non standard possono
    essere importati); ad esempio, gli interi di 9 bit.

  Il C permette di fare questo in una definizione di struttura, mettendo
  ":lunghezza-bit" dopo la variabile stessa, e cioe':

     struct packed-struct {
	unsigned int f1:1;
	unsigned int f2:1;
	unsigned int f3:1;
	unsigned int f4:1;
	unsigned int type:4;
	unsigned int funny_int:9;
	} pack;

  Qui la struttura packed-struct contiene 6 elementi: 4 flag da 1 bit (f1,...
  f4) e funny_int da 9 bit.

  Il C automaticamente raggruppa assieme i campi di bit elencati nell'esempio
  appena riportato.

  Solitamente si accede ai membri della struttura nel seguente modo:

     pack.type = 7;

  Notiamo che:

  - solamente "n" bit di basso livello possono essere assegnati ad un numero
    di "n" bit. Cosi' il campo "type" non puo' assumere valori maggiori di 15 
    (4 bits long);
  - i bit fields vengono sempre convertiti al tipo intero prima di eseguirvi
    delle operazioni;
  - e' permesso "mescolare" tipi normali con bit fields;
  - la definizione di "unsigned" e' importante, per assicurarsi che per i 
    flags non venga usato nessun bit per il segno.

------------------------------------------------------------------------------
07.05. Ordine di precedenza degli operatori 
------------------------------------------------------------------------------

  E' necessario fare attenzione al significato di un'espressione come
	a + b * c
  dove potremmo volere sia l'effetto di 
	(a + b) * c
  sia quello di 
	a + (b * c)
  Tutti gli operatori hanno una propria priorita', e gli operatori ad alta
  priorita' sono valutati prima di quelli a bassa priorita'.
  Gli operatori con la stessa priorita' sono valutati da sinistra a destra;
  Cosi'
	a - b - c
  e' valutato 
	(a - b) - c
  come ci si puo' aspettare.

  L'ordine di priorita', dalla piu' alta alla piu' bassa, degli operatori
  in C e':
 
  ()[]->.
  !~-*& sizeof cast ++ --
    (these are rigth -> left)
  */%
  +-
  < <=  >= >
  == !=
  &
  ^
  |
  &&
  ||
  ?: (right -> left)
  = += -= (right -> left)
  ,(comma)
  
  Quindi:
	"a < 10 &&2 * b < c" 
  e' interpretato come:
	"(a < 10) &&((2 * b) < c)".
  ed anche:
	a=
	    b=
		spokes / spokes_per_wheel
		+ spares;
  e' valutato come:
	a=
	    (b=
		(spokes / spokes_per_wheel)
		+ spares
	    );

------------------------------------------------------------------------------
08. Strutture di controllo 
------------------------------------------------------------------------------

  Quelli che seguono sono i vari metodi con cui il C puo' controllare il 
  flusso logico di un programma. A parte alcune minime differenze sintattiche,
  queste istruzioni sono simili a quelle che si possono trovare negli altri
  linguaggi.
  Come abbiamo visto, in C esistono le seguenti operazioni logiche:
	==,!=,||,&&.
  Un altro operatore e' il not "!" unario (ha un solo argomento).

  Questi operatori sono utilizzati congiuntamente alle istruzioni di seguito
  riportate.

------------------------------------------------------------------------------
08.01. If 
------------------------------------------------------------------------------

  L'istruzione "if" ha le stesse funzioni degli altri linguaggi. Puo' avere
  tre forme di base:

  if (expression)
    statement

  if (expression)
    statement1
  else
    statement2

  if (expression1)
    statement1
  else if (expression2)
    statement2
  else 
    statement3
    
  Ad esempio:
    
  	  int x,y,z;
  	  main()
  	   {
  	      int w;
  	      ...
  	      if (x<0)
  	        {
  	           z=w;
  	           ...
  	        }
              else
                {
		   z=y;
 		   ...
 	        }
 	    }

------------------------------------------------------------------------------
08.02. Operatore "?" 
------------------------------------------------------------------------------

  L' operatore ? (ternary condition) e' la forma piu' efficente per esprimere
  semplici if statements. Ha la seguente forma:
  
      expression1 ? expression2 : exprssion3
  
  che equivale a:
 
      if expression1 then expression2 else expression3
  
  Ad esempio:
    
      z=(a>b) ? a : b
    
      cioe'
    	 if (a>b)
  	   z=a;
      	 else
      	   z=b;
      	  
      assegna a z il massimo tra a e b.

------------------------------------------------------------------------------
08.03. Switch 
------------------------------------------------------------------------------

  Permette scelte multiple tra un insieme di items.
  La sua forma generale e':
   
	switch (expression) {
   	    case item1:
   	    		statement1;
   	    		break;
 	    case item2:
   	    		statement2;
   	    		break;
   	    		.
   	    		.
   	    		.
 	    case itemn:
   	    		statementn;
   	    		break;
 	    	
	    case default:
	     		statement;
	     		break;
	    }
	    
	   
  Il valore degli item deve essere una costante (le variabili non sono 
  permesse).
  Il break serve per terminare lo switch dopo l'esecuzione di una scelta, 
  altrimenti verra' valutato anche il caso successivo (questo, a differenza
  di molti altri linguaggi).
     
  E' possibile anche avere un'istruzione nulla, includendo solamente un ";" 
  oppure lasciando fallire l'istruzione di switch omettendo qualsiasi frase
  (come nell'esempio di seguito).

  Il caso "default" e' facoltativo e raggruppa tutti gli altri casi. 

  Ad esempio:
       switch (letter) {
            case 'A':
            case 'E':
            case 'I':
            case 'O':
            case 'U':
               numerovocali++;
               break;
            case " ":
               numerospazi++;
               break;
            default:
               numerocostanti++;
               break;
         }
             
  In questo caso se letter e' una vocale ('A','E','I','O','U') viene 
  incrementato il valore della varibile numerovocali, se e' uno spazio (" ")
  si incrementa numerospazi e altrimenti (se nessuno dei casi precedenti e' 
  vero) viene eseguita la condizione di default e quindi viene incrementato 
  numerocostanti.

------------------------------------------------------------------------------
08.04. For 
------------------------------------------------------------------------------

  L'istruzione C "for" ha la seguente forma:
      
     for (expression1; expression2; expression3)
        statement;
        {or block of statements}
      
     dove expression1 inizializza, expression2 e' il test di termine e
     expression3 e' il modificatore (che puo' anche essere piu' di un semplice
     incremento).
    
  Nota: fondamentalmente il C tratta le istruzioni "for" come i cicli di
         tipo "while".
 
  Ad esempio:
       
       int x;
       main()
       {
          for (i=0;i<3;i++)
            printf("x=%dn",x);
       }
     	   
  che genera come output sullo schermo:
       x=0
       x=1
       x=2
         
  Gli esempi che seguono sono tre forme valide delle istruzioni "for" in C:

	for (x=0;((x<3)&&(x>9));x++)

       	for (x=0,y=4;((x<3)&&(y>9));x++,y+=2)
     in cui si puo' notare che le espressioni multiple possono essere separate
     da una ",";

	for (x=0,y=4,z=4000;z;z/=10)
     in cui si puo' notare che il loop continua l'iterazione fino a quanto z
     diventa 0.

------------------------------------------------------------------------------
08.05. While 
------------------------------------------------------------------------------

  L'istruzione "while" ha la seguente forma:
   
     while (expression)
       statement;
          
  Ad esempio:

       int x=3;
       main()
       {
         while (x>0)
            {
               printf("x=%dn",x);
               x--;
            }
       }
       
  che genera come output sullo schermo:
       x=3
       x=2
       x=1
           
  While puo' accettare non solo condizioni ma anche espressioni, per cui 
  risultano corrette le seguenti istruzioni:
       while (x-);
       while (x=x+1);
       while (x+=5);

  Utilizzando questo tipo di espressioni, solo quando il risultato di x--,
  x=x+1 oppure x+=5 ha valore 0 la condizione di while fallisce e si esce
  dal loop.

  E' possibile avere anche complete operazioni di esecuzione nelle espressioni
  "while":

       while (i++<10)
  che incrementa i fino a raggiungere il valore 10;
         
       while ((ch=getchar())!'q')
          putchar(ch);
  che usa le funzioni getchar() e putchar() delle librerie standard, che 
  rispettivamente leggono un carattere dalla tastiera e scrivono un 
  determinato carattere sullo schermo. Il loop while continua a leggere dalla 
  tastiera e a visualizzare sullo schermo il carattere digitato, fino a quando
  non venga battuto il carattere "q". 

------------------------------------------------------------------------------
08.06. Do-While 
------------------------------------------------------------------------------

  L'istruzione C "do-while" ha la seguente forma:
    
     do
       statement;
       while (expression);
         
  (e' simile al Pascal repeat ... until, eccetto il fatto che l'espressione
   dell'istruzione do-while e' vera)
    
  Ad esempio:
      
       int x=3;
       main()
         {
             do {			/* le graffe sono superflue, visto */
               printf("x=%dn",x-);     /* che racchiudono solamente una   */
		}			/* istruzione                      */
             while (x>0);
         }
         
  Il cui output e':
       x=3
       x=2
       x=1

  Nota: l'operatore finale "x-" indica che viene usato il valore corrente 
        di x mentre stampa, e poi viene decrementato x.

------------------------------------------------------------------------------
08.07. Break e Continue 
------------------------------------------------------------------------------

  Il C fornisce due comandi per controllare i loop:
     
  break    - esce da un loop o da uno switch
  continue - salta una iterazione del loop
     
  Consideriamo il seguente esempio, dove leggiamo un valore integer e lo 
  elaboriamo in accordo con le seguenti condizioni. Se il valore che abbiamo
  letto e' negativo, dovremo stampare un messaggio di errore ed abbandonare
  il loop. Se il valore letto e' maggiore di 100, dovremo ignorarlo e 
  continuare con il successivo valore in input. Se il valore e' 0, dovremo
  terminare il loop.

     /* Viene letto un valore intero ed elaborato purche'
        sia maggiore di 0 e minore di 100 */

     while (scanf("%d".&value) == 1 && value !=0) {
        if (value<0) {
           printf("Valore non ammesson");
           break;  /* Abbandona il loop */
        }
        if (value>100) {
           printf("Valore non ammesson");
           continue; /Torna nuovamente all'inizio del loop */
        }
        /*Elabora il valore letto*/
        /*che e' sicuramente tra 0 e 100 */
        .
        .
        .
     }  

------------------------------------------------------------------------------
09. Arrays 
------------------------------------------------------------------------------

------------------------------------------------------------------------------
09.01. Array singoli e multidimensionali 
------------------------------------------------------------------------------

  Un esempio di definizione di un array in C e' :
    
	int elenco_numeri[50];
     
  e si accede agli elementi dell'array nel seguente modo:
    
 	terzo_numero= elenco_numeri[2];
    	elenco_numeri[5]=100;
             
  NB. In C gli Array subscripts iniziano da 0 e finiscono alla dimensione 
      dell'array meno uno.  Nell'esempio precedente il range e' 0-49, cioe' 
      elenco_numeri e' un array di 50 elementi e si ha:
      elenco_numeri[0],elenco_numeri[1],....elenco_numeri[49].
      Questa e' una grossa differenza fra il C e gli altri linguaggi e 
      richiede un po' di pratica per raggiungere "la giusta disposizione
      d'animo".
  
  Array multidimensionali sono cosi definiti:
  
	int tabella_numeri[50][50]         => per due dimensioni
    	int big_D[20][30][10][40]          => per piu' di due dimensioni
    
  e si accede agli elementi nel seguente modo:
    
    	numero=tabella_numeri[5][32];
    	tabella_numeri[1][23]=100;

------------------------------------------------------------------------------
09.02. Stringhe 
------------------------------------------------------------------------------

  In C le stringhe sono definite come array di caratteri. Ad esempio, la
  seguente istruzione definisce una stringa di 50 caratteri:
   
      char name[50];
   
  Il C non ha pero' un sistema maneggevole per costruire le stringhe, cosi 
  le seguenti assegnazioni non sono valide:
      char firstname[50], lastname[50], fullname[50];
      firstname = "Mario"                    /* illegale */
      lastname  = "Rossi"                    /* illegale */
      fullname  = "Sig."+firstname+lastname  /* illegale */
 
  Esiste pero' una libreria di routines per il trattamento delle stringhe
  ("< string.h >").

  Per maneggiare le stringhe si possono usare puntatori ad array di char 
  (come vedremo piu' avanti).
  
  Per stampare una stringa si usa printf() con lo speciale carattere di 
  controllo %s:
  
      printf("%s",nome);   

  Nota: e' sufficiente avere il nome della stringa.

  Al fine di permettere l'utilizzo di stringhe con lunghezza variabile,
  il carattere