Lezione del 19/6/2006

  • Esempi introduttivi

    File ex001.c

     1/*
 2  questo e' un commento:
 3
 4  inizia con il carattere / seguito da *
 5  finisce con il carattere * seguito da /
 6
 7*/
 8
 9/* commento su una singola riga */
10
11/*
12 * commento con abbellimento etc etc.
13 *
14 */
15
16int /* valore di ritorno di tipo intero */
17/* main e' il nome "ufficiale" del programma
18   principale, non esistono altri nomi */ 
19main()
20/* () le parentesi "contengono" gli argomenti
21  della funzione "main", in questo caso nessun
22  argomento */
23{
24  /*************************************\
25   * un blocco (di istruzioni) e'      *
26   *   "qualunque" contenuta tra { e } *
27  \*************************************/
28
29  return 0 ; /* valore restituito dalla funzione "main" */
30}
31
32/*
33  il C e' un liguaggio "free form" quindi
34  non ci sono regole di scrittura rigide.
35  Ad esempio potevo scrivere tutto su una
36  riga:
37  
38  int main() {}
39
40  per compilare il seguente programma su una
41  macchina UNIX con compilatore della GNU
42
43  gcc ex001.c
44
45  che genera l'eseguibile a.out
46
47  per attivare tutti i messaggi di avvertimento
48  (WARNING) si scrivera'
49
50  gcc -Wall ex001.c
51
52  per cambiare il nome (di default) dell'eseguibile
53  si scrivera'  
54
55  gcc -Wall ex001.c -o ex001
56
57  in questo modo l'eseguibile generato e' ex001.
58
59*/

    File ex002.c

     1int
 2main()
 3{
 4  /*
 5  // le stringhe in C sono lettere spazi etc
 6  // racchiuse tra doppi apici "
 7  // ad esepio "io sono una stringa" 
 8  */
 9
10  /*
11  // per controllare il cursore esistono
12  // una serie di caratteri speciali.
13  // Sono preceduti dal carattere di "escape" \ (backslash)
14  //
15  // \a  attiva il beep sul terminale
16  // \b  sposta il cursore di uno spazio a sinistra
17  // \f  form feed
18  // \n  new line (passa alla riga successiva)
19  // \r  mette il cursore a inizio riga
20  // \t  carattere di tabulazione
21  // \v  tabulazione verticale 
22  // \"  inserisce il carattere "
23  // \num num = 3 digit in ottale del carattere
24  //  ascii corrispondente
25  */
26
27  printf("ciao \"mamma\"\r") ; /* il ; separa le istruzioni */
28  printf("xyz\n") ;
29  printf("numero intero %d\n",123) ;
30  /* %d indica che in questo posto verra' stampato
31   * il valore dell'elemento successivo della lista
32   * degli argmenti di printf.
33   * In particolare d indica = decimale
34   */
35
36  return 0 ;
37}

    File ex003.c

      1#include <stdio.h> /* da spiegare piu' avanti */
  2
  3/*
  4 * in C esistono un certo numeri di "tipi"
  5 * numerici predefiniti:
  6 *
  7 * int = intero con segno, tipicamente composto
  8 *       da 2 o 4 o 8 byte. Il numero di byte e'
  9 *       quello della "parola" (word) del processore.
 10 *       Ad esempio su processori a 32 bit (4 byte)
 11 *       l'intero e' di 4 byte.
 12 *
 13 * float  = numero floating point in singola precisione
 14 *          tipicamante 4 byte
 15 *
 16 * double = numero floating point in doppia precisione
 17 *          tipicamante 8 byte
 18 *
 19 * char = tipo carattere, un byte usato per memorizzare
 20 *        un carattere (ascii)
 21 *
 22 */
 23
 24/*
 25 * A questi tipi si possono mettere dei "modificatori"
 26 *
 27 *
 28 * unsigned = si applica a int e char.
 29 *            l'intero e il carattere non hanno segno
 30 *            unsigned int
 31 *            unsigned char.
 32 *            Di solito si usa la forma abbreviata
 33 *            unsigned = unsigned int
 34 *
 35 * short    = si applica a int
 36 *            short int e' un intero che puo' usare
 37 *            meno byte di int, tipicamente 2 byte
 38 *            su un processore a 32 bit.
 39 *            Di solito si usa la forma abbreviata
 40 *            short = short int
 41 *
 42 * long     = si applica a int e double
 43 *            long int e' un intero che puo' usare
 44 *            piu' byte di int, tipicamente 8 byte
 45 *            su un processore a 32 bit.
 46 *            long double e' una numero floating
 47 *            point di precisione quadrupla.
 48 *            Non e' implementato su tutti i compilatori.
 49 *
 50 */
 51
 52int
 53main()
 54{
 55  /*
 56   * alcuni esmopi d'uso
 57   */
 58
 59  int i, j, k ; /* definisco le variabili i,j,k
 60                   come varibili intere con segno */
 61
 62  short l, m ;  /* definisco le variabili l,m
 63                   come varibili intere "corte" con segno */
 64 
 65  float a, b ; /* definisco le variabili a,b 
 66                  come varibili floating point
 67                  in singola precisione */
 68
 69  double c, d ; /* definisco le variabili c, d
 70                   come varibili floating point
 71                   in doppia precisione */
 72
 73  unsigned int o, p ; /* definisco le variabili o, p
 74                         come varibili intere 
 75                         senza segno */
 76
 77  unsigned long int r, s ; /* definisco le variabili r, s
 78                              come varibili intere 
 79                              senza segno "lunghe" */
 80
 81  /*
 82   * sizeof(argument) : argument e' un tipo
 83   *                    restituisce il numero di byte
 84   *                    usato per rappresentarlo 
 85   *
 86   */
 87
 88  printf("n. byte per tipo \"char\" %ld\n", sizeof(char)) ;
 89  printf("n. byte per tipo \"short\" %ld\n", sizeof(short)) ;
 90  printf("n. byte per tipo \"int\" %ld\n", sizeof(int)) ;
 91  printf("n. byte per tipo \"long\" %ld\n", sizeof(long)) ;
 92  printf("n. byte per tipo \"float\" %ld\n", sizeof(float)) ;
 93  printf("n. byte per tipo \"double\" %ld\n", sizeof(double)) ;
 94  
 95
 96  /* assegnazioni varie */
 97  i = 11 ;
 98  j = 23 ; k = 3434 ; /* posso scrivere piu'
 99                     instruzioni per riga */
100
101  printf("numeri in decimale i=%d j=%10d k=%-10d***\n",i,j,k) ;
102
103  /* stampo i numeri in ottale */
104  printf("numeri in ottale i=%o j=%10o k=%-10o***\n",i,j,k) ;
105
106  /* stampo i numeri in esadecimale */
107  printf("numeri in ottale i=%x j=%10x k=%-10X***\n",i,j,k) ;
108 
109  /*
110  // Formattazione stampa interi
111  //
112  // %d    intero decimale
113  // %ld   intero long decimale
114  // %o    intero in ottale
115  // %x %X intero in esadecimale
116  //
117  // %23d  riservo 23 spazi per la stampa
118  //       con allineamento a a destra
119  // %-12d riservo 12 spazi per la stampa
120  //       con allineamento a sinistra
121  */
122
123  l = m = -12 ; /* equivalente a scrivere 
124                  m = 12 ; l = m ; */
125
126  printf("numeri (short) l=%d m=%10d\n",l,m) ;
127
128  a = b = 1.2f ; /* f e' postfisso per indicare
129                    la singola precisione */
130
131  printf("numeri (float) a[%%f]=%f b[%%10f]=%10f\n",a,b) ;
132  printf("numeri (float) a[%%10.2f]=%10.2f b[%%-10.4f]=%-10.4f\n",a,b) ;
133  
134  c = 1.2 ;
135  d = 2 ;
136
137  printf("numeri (double) c[%%lf]=%lf d[%%10lf]=%10lf\n",c,d) ;
138  printf("numeri (double) c[%%10.2lf]=%10.2lf d[%%-10.4lf]=%-10.4lf\n",c,d) ;
139
140  /*
141  // Formattazione stampa numeri in floating point
142  //
143  // %f      singola precisione
144  // %lf     doppia precisione
145  // %10f    riservo 10 spazi per la stampa
146  // %10.4f  riservo 10 spazi per la stampa, 4 per la parte decimale
147  // %-10f   riservo 10 spazi per la stampa allineato a sinista
148  //
149  // al posto di "f" posso usare "e" per formato esponenziale
150  // 12.34 ==> 1.234E1 E1 = 10^1
151  //
152  // al posto di "f" posso usare "g" per formato esponenziale
153  // quando conviene
154  //
155  */
156  printf("numeri (double) c[%%lg]=%lg d[%%10lg]=%10lg\n",c,d) ;
157  printf("numeri (double) c[%%10.2le]=%10.2le d[%%-10.4le]=%-10.4le\n",c,d) ;
158
159  o = -1 ; /* occhio! assegno intero con segno ad un unsigned */
160  p = 2  ;
161
162  r = s = 12 ;
163
164  return 0 ;
165}

    File ex004.c

     1#include <stdio.h>
 2
 3
 4/*
 5 *  esempio programma che calcola n esimo 
 6 *  numero di Fibonacci.
 7 *
 8 *  F(n) = n esimo numero di Finonacci
 9 *
10 *  F(0) = 1
11 *  F(1) = 1
12 *  F(n+1) = F(n) + F(n-1) n =1,2,3,... 
13 *
14 *
15 *  1,1,2,3,5,8,....
16 *
17 */
18
19
20int
21main()
22{
23
24  int fk, fkp1, fkm1, k, n ; /* variabili usate dall'algoritmo */
25
26  /* stampa sul terminale il messaggio
27     che richiede il rangop del numero da calcolare */
28
29  printf("Calcolo del n-esimo numero di Fibonacci\n" /* stringa su piu' righe */
30         "inserisci n: " ) ;
31
32  /* lettura da terminale del numero n */
33  scanf("%d",&n) ; /* & estrae l'indirizzo della variabile n */
34
35  printf("Hai inserito il numero n = %d\n", n) ;
36
37  /*
38   * if ( espressione logica ) istruzione ;
39   *
40   * istruzione puo' essere anche un blocco di istruzioni
41   * racchiuse da { }
42   *
43   */
44
45  if ( n == 0 ) {
46    printf("F(0) = 1\n") ; /* stampo il risultato */
47    return 0 ; /* esco dal programma "bene" */
48  }
49
50  if ( n == 1 ) {
51    printf("F(1) = 1\n") ; /* stampo il risultato */
52    return 0 ; /* esco dal programma "bene" */
53  }
54
55  fkm1 = fk = 1 ; /* parto con k = 1 */
56  k    = 1 ;      /* intero per il ciclo */
57
58loop_label: /* etichetta per fare dei goto */
59  
60  fkp1 = fk + fkm1 ;
61  k = k + 1 ; 
62  /* shift degli elementi */
63  fkm1 = fk ;
64  fk   = fkp1 ;
65
66  /* controllo se ho finito il ciclo */
67  if ( k != n ) goto loop_label;
68    /* instruzione goto "salta" alla etichetta "loop_label".
69     * Etichetta e' una qualunue sequenza alfanumerica (senza spazi)
70     *
71     */
72
73  printf("F(%d) = %d\n", n, fk) ; /* stampo il risultato */
74
75  return 0 ;
76}

  • Calcolo dei numeri di Fibonacci (varie versioni)

    File ex005a.c

     1#include <stdio.h>
 2
 3
 4/*
 5 *  esempio programma che calcola n esimo 
 6 *  numero di Fibonacci.
 7 *
 8 *  F(n) = n esimo numero di Finonacci
 9 *
10 *  F(0) = 1
11 *  F(1) = 1
12 *  F(n+1) = F(n) + F(n-1) n =1,2,3,... 
13 *
14 *
15 *  1,1,2,3,5,8,....
16 *
17 * USANDO PERO:
18 *  -- while ( ) ;
19 *  -- do { } while ( ) ;
20 *  -- for (;;) ;
21 *
22 * esempio con while
23 *
24 */
25
26
27int
28main()
29{
30
31  int fk, fkp1, fkm1, k, n ; /* variabili usate dall'algoritmo */
32
33  /* stampa sul terminale il messaggio
34     che richiede il rangop del numero da calcolare */
35
36  printf("Calcolo del n-esimo numero di Fibonacci\n" /* stringa su piu' righe */
37         "inserisci n: " ) ;
38
39  /* lettura da terminale del numero n */
40  scanf("%d",&n) ; /* & estrae l'indirizzo della variabile n */
41
42  printf("Hai inserito il numero n = %d\n", n) ;
43
44  /*
45   * if ( espressione logica ) istruzione ;
46   *
47   * istruzione puo' essere anche un blocco di istruzioni
48   * racchiuse da { }
49   *
50   */
51
52  if ( n == 0 ) {
53    printf("F(0) = 1\n") ; /* stampo il risultato */
54    return 0 ; /* esco dal programma "bene" */
55  }
56
57  if ( n == 1 ) {
58    printf("F(1) = 1\n") ; /* stampo il risultato */
59    return 0 ; /* esco dal programma "bene" */
60  }
61
62  /*
63   * calcolo numero di FIbonacci usano il while
64   *
65   *  while ( test ) istruzione ;
66   *
67   * e' equivalente alle seguenti istruzioni
68   *
69   * loop_label:
70   *   if ( not test ) goto exit_loop ;
71   *   istruzione ;
72   *   goto loop_label ;
73   * exit_loop ;
74   *
75   */
76
77  fkm1 = fk = 1 ; /* parto con k = 1 */
78  k    = 1 ;      /* intero per il ciclo */
79
80  while ( k < n ) {
81    fkp1 = fk + fkm1 ;
82    k = k + 1 ;
83    /* shift degli elementi */
84    fkm1 = fk ;
85    fk   = fkp1 ;
86  }
87
88  printf("F(%d) = %d\n", n, fk) ; /* stampo il risultato */
89
90  return 0 ;
91}

    File ex005b.c

     1#include <stdio.h>
 2
 3
 4/*
 5 *  esempio programma che calcola n esimo 
 6 *  numero di Fibonacci.
 7 *
 8 *  F(n) = n esimo numero di Finonacci
 9 *
10 *  F(0) = 1
11 *  F(1) = 1
12 *  F(n+1) = F(n) + F(n-1) n =1,2,3,... 
13 *
14 *
15 *  1,1,2,3,5,8,....
16 *
17 * USANDO PERO:
18 *  -- while ( ) ;
19 *  -- do { } while ( ) ;
20 *  -- for (;;) ;
21 *
22 * esempio con do {} while ()
23 *
24 */
25
26
27int
28main()
29{
30
31  int fk, fkp1, fkm1, k, n ; /* variabili usate dall'algoritmo */
32
33  /* stampa sul terminale il messaggio
34     che richiede il rangop del numero da calcolare */
35
36  printf("Calcolo del n-esimo numero di Fibonacci\n" /* stringa su piu' righe */
37         "inserisci n: " ) ;
38
39  /* lettura da terminale del numero n */
40  scanf("%d",&n) ; /* & estrae l'indirizzo della variabile n */
41
42  printf("Hai inserito il numero n = %d\n", n) ;
43
44  /*
45   * if ( espressione logica ) istruzione ;
46   *
47   * istruzione puo' essere anche un blocco di istruzioni
48   * racchiuse da { }
49   *
50   */
51
52  if ( n == 0 ) {
53    printf("F(0) = 1\n") ; /* stampo il risultato */
54    return 0 ; /* esco dal programma "bene" */
55  }
56
57  if ( n == 1 ) {
58    printf("F(1) = 1\n") ; /* stampo il risultato */
59    return 0 ; /* esco dal programma "bene" */
60  }
61
62  /*
63   * calcolo numero di FIbonacci usano il while
64   *
65   *  do { istruzione } while ( test ) ;
66   *
67   * e' equivalente alle seguenti istruzioni
68   *
69   * loop_label:
70   *   istruzione ;
71   * if ( test ) goto loop_label ;
72   *
73   */
74
75  fkm1 = fk = 1 ; /* parto con k = 1 */
76  k    = 1 ;      /* intero per il ciclo */
77
78  do {
79    fkp1 = fk + fkm1 ;
80    k = k + 1 ;
81    /* shift degli elementi */
82    fkm1 = fk ;
83    fk   = fkp1 ;
84  } while ( k < n ) ;
85
86  printf("F(%d) = %d\n", n, fk) ; /* stampo il risultato */
87
88  return 0 ;
89}

    File ex005c.c

      1#include <stdio.h>
  2
  3
  4/*
  5 *  esempio programma che calcola n esimo 
  6 *  numero di Fibonacci.
  7 *
  8 *  F(n) = n esimo numero di Finonacci
  9 *
 10 *  F(0) = 1
 11 *  F(1) = 1
 12 *  F(n+1) = F(n) + F(n-1) n =1,2,3,... 
 13 *
 14 *
 15 *  1,1,2,3,5,8,....
 16 *
 17 * USANDO PERO:
 18 *  -- while ( ) ;
 19 *  -- do { } while ( ) ;
 20 *  -- for (;;) ;
 21 *
 22 * esempio con for (;;) ;
 23 *
 24 */
 25
 26
 27int
 28main()
 29{
 30
 31  int fk, fkp1, fkm1, k, n ; /* variabili usate dall'algoritmo */
 32
 33  /* stampa sul terminale il messaggio
 34     che richiede il rangop del numero da calcolare */
 35
 36  printf("Calcolo del n-esimo numero di Fibonacci\n" /* stringa su piu' righe */
 37         "inserisci n: " ) ;
 38
 39  /* lettura da terminale del numero n */
 40  scanf("%d",&n) ; /* & estrae l'indirizzo della variabile n */
 41
 42  printf("Hai inserito il numero n = %d\n", n) ;
 43
 44  /*
 45   * if ( espressione logica ) istruzione ;
 46   *
 47   * istruzione puo' essere anche un blocco di istruzioni
 48   * racchiuse da { }
 49   *
 50   */
 51
 52  if ( n == 0 ) {
 53    printf("F(0) = 1\n") ; /* stampo il risultato */
 54    return 0 ; /* esco dal programma "bene" */
 55  }
 56
 57  if ( n == 1 ) {
 58    printf("F(1) = 1\n") ; /* stampo il risultato */
 59    return 0 ; /* esco dal programma "bene" */
 60  }
 61
 62  /*
 63   * calcolo numero di FIbonacci usano il while
 64   *
 65   * for ( inizializzazione ; test ; incremento ) istruzione ;
 66   *
 67   * e' equivalente alle seguenti istruzioni
 68   *
 69   * inizializzazione ;
 70   * loop_label:
 71   *   if ( not test ) goto exit_loop ;
 72   *   istruzione ;
 73   *   incremento ;
 74   *   goto loop_label ;
 75   * exit_loop:
 76   *
 77   * e' equivalente anche al seguente "while loop"
 78   *
 79   * inizializzazione ;
 80   * while ( test ) { instruzione ; incremento ; }
 81   *
 82   * OSSERVAZIONE:
 83   *
 84   * for ( ; test ; ) istruzione ;
 85   * e' equivalente
 86   * while ( test ) istruzione ;
 87   *
 88   */
 89
 90  fkm1 = fk = 1 ; /* parto con k = 1 */
 91  k    = 1 ;      /* intero per il ciclo */
 92
 93  for ( fkm1 = fk = 1, k=1 ; /* blocco inizializzazione
 94                                uso la virgola per separare
 95                                le instruzioni */ 
 96        k < n ; /* test di fine ciclo */
 97        ++k /* incremento 
 98               ++k e' equivalente a k = k+1 
 99             */
100       ) {
101    fkp1 = fk + fkm1 ;
102    /* shift degli elementi */
103    fkm1 = fk ;
104    fk   = fkp1 ;
105  } ;
106
107  printf("F(%d) = %d\n", n, fk) ; /* stampo il risultato */
108
109  return 0 ;
110}

    File ex005d.c

     1#include <stdio.h>
 2
 3
 4/*
 5 *  esempio programma che calcola n esimo 
 6 *  numero di Fibonacci.
 7 *
 8 *  F(n) = n esimo numero di Finonacci
 9 *
10 *  F(0) = 1
11 *  F(1) = 1
12 *  F(n+1) = F(n) + F(n-1) n =1,2,3,... 
13 *
14 *
15 *  1,1,2,3,5,8,....
16 *
17 * USANDO PERO la definizione ricorsiva!
18 */
19
20int /* tipo restituito dalla funzione Fibonacci */
21Fibonacci /* nome della funzione: Fibonacci */
22(int n) /* argomenti della funzione:
23           uno solo di tipo intero */
24{ /* corpo della funzione */
25  
26  if ( n == 0 || n == 1 ) return 1 ;
27  /* || e' l'operatore di or logico, 
28     vale "true" se almento una delle due 
29     condizioni e' vera */
30  /* altri operatori sono 
31     && and logico
32     !  negazione */
33
34  /* uso della definizione ricorsiva */
35
36  return Fibonacci(n-1)+Fibonacci(n-2) ;
37}
38
39
40int
41main()
42{
43
44  int n ;
45
46  /* stampa sul terminale il messaggio
47     che richiede il rangop del numero da calcolare */
48
49  printf("Calcolo del n-esimo numero di Fibonacci\n" /* stringa su piu' righe */
50         "inserisci n: " ) ;
51
52  /* lettura da terminale del numero n */
53  scanf("%d",&n) ; /* & estrae l'indirizzo della variabile n */
54
55  printf("Hai inserito il numero n = %d\n", n) ;
56
57  printf("F(%d) = %d\n", n, Fibonacci(n)) ; /* stampo il risultato */
58
59  return 0 ;
60}

    File ex005e.c

     1#include <stdio.h>
 2
 3
 4/*
 5 *  esempio programma che calcola n esimo 
 6 *  numero di Fibonacci.
 7 *
 8 *  F(n) = n esimo numero di Finonacci
 9 *
10 *  F(0) = 1
11 *  F(1) = 1
12 *  F(n+1) = F(n) + F(n-1) n =1,2,3,... 
13 *
14 *
15 *  1,1,2,3,5,8,....
16 *
17 * USANDO PERO la definizione ricorsiva!
18 * e l'istruzione switch
19 */
20
21int /* tipo restituito dalla funzione Fibonacci */
22Fibonacci /* nome della funzione: Fibonacci */
23(int n) /* argomenti della funzione:
24           uno solo di tipo intero */
25{ /* corpo della funzione */  
26  switch ( n ) {
27  case 0:
28  case 1:
29    return 1 ;
30  default:
31    return Fibonacci(n-1)+Fibonacci(n-2) ;
32  }
33}
34
35int
36main()
37{
38
39  int n ;
40
41  /* stampa sul terminale il messaggio
42     che richiede il rangop del numero da calcolare */
43
44  printf("Calcolo del n-esimo numero di Fibonacci\n" /* stringa su piu' righe */
45         "inserisci n: " ) ;
46
47  /* lettura da terminale del numero n */
48  scanf("%d",&n) ; /* & estrae l'indirizzo della variabile n */
49
50  printf("Hai inserito il numero n = %d\n", n) ;
51
52  printf("F(%d) = %d\n", n, Fibonacci(n)) ; /* stampo il risultato */
53
54  return 0 ;
55}

  • Esempio di funzione con compilazione separata

    File ex006a.c

     1#include <stdio.h>
 2
 3/*
 4 *  esempio programma che calcola n esimo 
 5 *  numero di Fibonacci.
 6 *  Usando la funzione "esterna" Fibonacci
 7 */
 8
 9/* il prototipo scritto qui e' erroro prone!!!
10   meglio con l'include */
11
12extern int Fibonacci(int n) ;
13
14int
15main()
16{
17  int n ;
18
19  /* stampa sul terminale il messaggio
20     che richiede il rangop del numero da calcolare */
21
22  printf("Calcolo del n-esimo numero di Fibonacci\n" /* stringa su piu' righe */
23         "inserisci n: " ) ;
24
25  /* lettura da terminale del numero n */
26  scanf("%d",&n) ; /* & estrae l'indirizzo della variabile n */
27
28  printf("Hai inserito il numero n = %d\n", n) ;
29
30  printf("F(%d) = %f\n", n, Fibonacci(n)) ; /* stampo il risultato */
31
32  return 0 ;
33}

    File ex006b.c

     1#include <stdio.h>
 2
 3/*
 4 *  esempio programma che calcola n esimo 
 5 *  numero di Fibonacci.
 6 *
 7 *  F(n) = n esimo numero di Finonacci
 8 *
 9 *  F(0) = 1
10 *  F(1) = 1
11 *  F(n+1) = F(n) + F(n-1) n =1,2,3,... 
12 *
13 *
14 *  1,1,2,3,5,8,....
15 *
16 * USANDO PERO la definizione ricorsiva!
17 * e l'istruzione switch
18 */
19
20int /* tipo restituito dalla funzione Fibonacci */
21Fibonacci /* nome della funzione: Fibonacci */
22(int n) /* argomenti della funzione:
23           uno solo di tipo intero */
24{ /* corpo della funzione */  
25  switch ( n ) {
26  case 0:
27  case 1:
28    return 1 ;
29  default:
30    return Fibonacci(n-1)+Fibonacci(n-2) ;
31  }
32}
33
34/*
35 * Per compilarlo uso
36 * gcc -Wall -c ex006b.c
37 *
38 * lo swicth -c indica al compilatore che non 
39 * deve "linkare" in un eseguibile ma produrre
40 * un file oggetto ex006b.o
41 *
42 * per usarlo col programma principale posso usare
43 * indifferentemente:
44 *
45 * gcc -Wall -c ex006a.c ## fase di compilazione
46 * gcc -Wall -c ex006b.c ## fase di compilazione
47 * gcc ex006a.o ex006b.o -o ex006 ## linking
48 *
49 * oppure
50 *
51 * gcc -Wall -c ex006b.c ## fase di compilazione
52 * gcc -Wall ex006a.c ex006b.o -o ex006 ## compila & linking
53 *
54 * oppure
55 *
56 * gcc -Wall ex006a.c ex006b.c -o ex006 ## compila & linking tutto in uno
57 *
58 */

  • Stesso esempio ma con file .h

    File ex007a.c

     1#include <stdio.h>
 2#include "ex007.h"
 3
 4/*
 5 *  esempio programma che calcola n esimo 
 6 *  numero di Fibonacci.
 7 *  Usando la funzione "esterna" Fibonacci
 8 */
 9
10
11int
12main()
13{
14  int n ;
15
16  /* stampa sul terminale il messaggio
17     che richiede il rangop del numero da calcolare */
18
19  printf("Calcolo del n-esimo numero di Fibonacci\n" /* stringa su piu' righe */
20         "inserisci n: " ) ;
21
22  /* lettura da terminale del numero n */
23  scanf("%d",&n) ; /* & estrae l'indirizzo della variabile n */
24
25  printf("Hai inserito il numero n = %d\n", n) ;
26
27  printf("F(%d) = %d\n", n, Fibonacci(n)) ; /* stampo il risultato */
28
29  return 0 ;
30}

    File ex007b.c

     1#include <stdio.h>
 2/* le stringhe tra <> indicano file da cercare
 3   nelle directory di sistema.
 4   Tipicamente /usr/include, ma puo' cambiare
 5   da compilatore a compilatore
 6*/
 7
 8#include "ex007.h"
 9/* le stringhe tra "" indicano file da cercare
10   nelle directory corrente o nelle directory
11   indicate dagli swicth -I del compilatore.
12   Ad esempio
13
14   gcc ....  -Imiei_iclude -I./altri_miei_iclude \
15             -I../ancora_altri_miei_iclude \
16             -I/path_assoluto/etc/
17
18 */
19
20/*
21 *  esempio programma che calcola n esimo 
22 *  numero di Fibonacci.
23 *
24 *  F(n) = n esimo numero di Finonacci
25 *
26 *  F(0) = 1
27 *  F(1) = 1
28 *  F(n+1) = F(n) + F(n-1) n =1,2,3,... 
29 *
30 *
31 *  1,1,2,3,5,8,....
32 *
33 * USANDO PERO la definizione ricorsiva!
34 * e l'istruzione switch
35 */
36
37int /* tipo restituito dalla funzione Fibonacci */
38Fibonacci /* nome della funzione: Fibonacci */
39(int n) /* argomenti della funzione:
40           uno solo di tipo intero */
41{ /* corpo della funzione */  
42  switch ( n ) {
43  case 0:
44  case 1:
45    return 1 ;
46  default:
47    return Fibonacci(n-1)+Fibonacci(n-2) ;
48  }
49}
50
51/*
52 * Per compilarlo uso
53 * gcc -Wall -c ex006b.c
54 *
55 * lo swicth -c indica al compilatore che non 
56 * deve "linkare" in un eseguibile ma produrre
57 * un file oggetto ex006b.o
58 *
59 * per usarlo col programma principale posso usare
60 * indifferentemente:
61 *
62 * gcc -Wall -c ex006a.c ## fase di compilazione
63 * gcc -Wall -c ex006b.c ## fase di compilazione
64 * gcc ex006a.o ex006b.o -o ex006 ## linking
65 *
66 * oppure
67 *
68 * gcc -Wall -c ex006b.c ## fase di compilazione
69 * gcc -Wall ex006a.c ex006b.o -o ex006 ## compila & linking
70 *
71 * oppure
72 *
73 * gcc -Wall ex006a.c ex006b.c -o ex006 ## compila & linking tutto in uno
74 *
75 */

    File ex007.h

    1/* definizione del prototipo di Fibonacci */
2
3extern int Fibonacci(int n) ;