Lezione del 13/3/2007

Esempi introduttivi

File esempio1.c

:open:
 1/*
 2 I commenti sono contenuti
 3 da / + * = inizio commento
 4 fino a * + / = fine commento
 5*/
 6
 7/* struttura di un programma C */
 8
 9/* un programma a' una funzione col 
10   nome fissato "main".
11   Restituisce un intero (int).
12   Il corpo del programma e' contenuto
13   tra { }.
14   Le parentesi () possono contenere
15   gli argomenti passati al programma
16   (da vedere più avanti)
17*/
18
19int
20main() {
21  return 0 ; 
22  /* ritorna 0 = nessun errore */
23}
24
25/*
26  per compilarlo uso su macchine UNIX
27
28  > gcc esempio1.c -o esempio1
29*/

File esempio2.c

:open:
 1int
 2main() {
 3  int                a, b, c ; /* definisco le variabili intere a, b, c */
 4  long  int          d, e, f ; /* interi "lunghi" */
 5  short int          g, h    ; /* interi "corti" */
 6  unsigned int       i ; /* interi senza segno */
 7  unsigned short int j ; /* interi "corti" senza segno */
 8  
 9  unsigned
10  long 
11  int k ; /* interi "lunghi" senza segno */
12
13  /* si possono usare le forme contratte 
14   unsigned int       = unsigned
15   long int           = long
16   short int          = short
17   signed int         = int
18   unsigned long int  = unsigned long
19   unsigned short int = unsigned short
20  */
21
22  /* operazioni sugli interi */
23  a = b + c ; /* somma */
24  a = b - c ; /* differenza */
25  a = b * c ; /* prodotto */
26  a = b / c ; /* divisione intera  10/4 ==> 2 */
27  a = b % c ; /* resto della divisione 20 % 3 ==> 2 
28                 infatti 20 = 3*6 + 2 */
29  return 0 ; 
30}
31
32/*
33  per compilarlo uso su macchine UNIX
34  > gcc esempio2.c -o esempio2
35*/

Manipolazione di bit

File esempio3.c

:open:
  1/* 
  2  uso direttiva di compilazione 
  3
  4  #include <file>
  5
  6  dove <> indica di cercare il file corrispondente
  7  nelle directory di sistema per il compilatore C
  8  normalmente /usr/include
  9  
 10 */
 11
 12#include <stdio.h>
 13
 14/* funzione (subroutine) che converte un intero in una stringa
 15   che rappresenta il numero in binario,
 16 */
 17
 18void
 19to_binary( int aa, char str[33] ) {
 20  int j, i = 0 ;
 21  unsigned a = (unsigned) aa ;
 22  /*
 23    while ( cond ) expression ;
 24    esegue espression finché cond e' vera
 25  */
 26  /* 
 27    operatori di confronto
 28    == uguaglianza
 29    != diverso
 30    >= maggiore o uguale
 31    <= minore o uguale
 32    > maggiore
 33    < minore
 34  */
 35 
 36  while ( a != 0 ) { 
 37	str[i] = '0' + (a%2) ;
 38  /* str[i] accedo all'i-esimo carattere della stringa str (a partire da 0) */
 39	a /= 2 ; /* scorciatoia per scrivere a = a / 2 ;
 40	            in generale a OP= b ; ==> a = a OP b  */
 41	/* si può anche scrivere come a >>= 1 ; == dividere a per 2 */
 42	++i ;    /* scorciatoia per i = i+1 ; */
 43  }
 44  if ( i == 0 ) { str[0] = '0' ; ++i ; }
 45  str[i] = '\0' ; /* marco il fine stringa */
 46  /* devo rovesciare la stringa */
 47  /* for ( INIT ; COND ; INCR ) expression ;
 48     INIT e' eseguita una volta sola a inizio ciclo
 49     COND viene testata ogni ciclo all'inizio, se falsa esce dal ciclo for
 50     INCR viene eseguita alla fine di ogni ciclo
 51     expression viene eseguita ad ogni ciclo
 52  */
 53  --i ; /* per non scambiare lo 0 marcatore di fine stringa */
 54  for ( j=0 ; j < i ; --i, ++j ) {
 55    /* scambio str[i] con str[j] */
 56	char bf = str[i] ;
 57	str[i] = str[j] ;
 58	str[j] = bf ;
 59  }
 60}
 61
 62int
 63main() {
 64  int       a = 112 ; /* definione e inizializzazione contestuale */
 65  int       b = 203 ;
 66  int const c = 322 ; /* c non può piu essere modificato */
 67  int       d ;
 68  char      str1[33] ; /* vettore di 33 caaratteri */
 69  char      str2[33] ; /* vettore di 33 caaratteri */
 70  char      str3[33] ; /* vettore di 33 caaratteri */
 71
 72  /* operazioni sugli interi */
 73  a = b + c ; /* somma */
 74  /* print e' definita in stdio.h 
 75     print( formato, argomenti ) ;
 76     formato   = "stringa" descrizione di come stampare a terminale gli argomenti
 77     argomenti =  lista separata da "," di variabili
 78  */
 79  printf("%d = %d + %d\n", a, b, c ) ;
 80  /* 
 81      ^  ^    ^     ^ ^   ^  ^  ^
 82      |  |    |     | |   |  |  |
 83      |  |    |     | |   +--+--+-- argomenti in stampa 
 84      |  |    |     | |
 85      |  |    |     | +------------ carattere non stampabile (ritorno a capo + avanza linea)
 86      |  |    |     |
 87      |  +----+-----+--- %d formattatore = prende argomento e lo stampa come intero
 88      |
 89      +------ chiama la funzione printf della libreria standard 
 90   */
 91  a = b - c ; /* differenza */
 92  printf("%d = %d - %d\n", a, b, c ) ;
 93  a = b * c ; /* prodotto */
 94  printf("%d = %d * %d\n", a, b, c ) ;
 95  a = b / c ; /* divisione intera  10/4 ==> 2 */
 96  printf("%d = %d / %d\n", a, b, c ) ;
 97  a = b % c ; /* resto della divisione 20 % 3 ==> 2 
 98                 infatti 20 = 3*6 + 2 */
 99  printf("%d = %d %% %d\n", a, b, c ) ;
100
101  /*
102   Manipolazione di BIT!
103
104  */
105
106  a = b << 1 ; /* shift a sinistra di 1 bit */
107  
108  printf("%d = %d<<1\n", a, b) ;
109  to_binary(a, str1) ;
110  to_binary(b, str2) ;
111  printf("%s = %s<<1\n", str1, str2) ;
112
113  a = b << 5 ; /* shift a sinistra di 5 bit */
114  printf("%d = %d<<5\n", a, b) ;
115  to_binary(a, str1) ;
116  to_binary(b, str2) ;
117  printf("%s = %s<<5\n", str1, str2) ;
118
119
120  a = b >> 1 ; /* shift a destra di 1 bit */
121  printf("%d = %d>>1\n", a, b) ;
122  to_binary(a, str1) ;
123  to_binary(b, str2) ;
124  printf("%s = %s>>1\n", str1, str2) ;
125
126  a = b >> 5 ; /* shift a destra di 5 bit */
127  printf("%d = %d>>5\n", a, b) ;
128  to_binary(a, str1) ;
129  to_binary(b, str2) ;
130  printf("%s = %s>>5\n", str1, str2) ;
131
132  /* operazioni maschere bit a bit
133    & operazione 'and' bit a bit
134    | operazione 'or' bit a bit
135    ^ operazione 'or esclusivo' bit a bit
136    ~ operazione 'complementazione' bit a bit
137  */
138
139  a = b & c ; /* and bit a bit */
140  to_binary(a, str1) ;
141  to_binary(b, str2) ;
142  to_binary(c, str3) ;
143  printf("%s = %s & %s\n", str1, str2, str3) ;
144
145  a = b | c ; /* or bit a bit */
146  to_binary(a, str1) ;
147  to_binary(b, str2) ;
148  to_binary(c, str3) ;
149  printf("%s = %s | %s\n", str1, str2, str3) ;
150
151  a = b ^ c ; /* or esclusivo bit a bit */
152  to_binary(a, str1) ;
153  to_binary(b, str2) ;
154  to_binary(c, str3) ;
155  printf("%s = %s ^ %s\n", str1, str2, str3) ;
156
157  a = ~b ; /* complemento bit a bit */
158  to_binary(a, str1) ;
159  to_binary(b, str2) ;
160  printf("%s = ~%s\n", str1, str2) ;
161
162  d = b & 0xFF ; /* controllo se i primi 8 bit sono assegnati */
163  to_binary(0xFF, str1) ;
164  to_binary(b,    str2) ;
165  printf("%d = %s & %s\n", d, str1, str2) ;
166
167  d = (b<<8) & 0xFF ; /* controllo se i primi 8 bit sono assegnati */
168  to_binary(0xFF, str1) ;
169  to_binary((b<<8), str2) ;
170  printf("%d = %s & %s\n", d, str1, str2) ;
171
172  return 0 ; 
173}
174
175/*
176  per compilarlo uso su macchine UNIX
177  > gcc esempio2.c -o esempio2
178*/

Il sizeof

File esempio4.c

:open:
 1/* 
 2 */
 3
 4#include <stdio.h>
 5
 6int
 7main() {
 8
 9  char        a ;
10  int         b ;
11  short       c ;
12  long        d ;
13  long long   e ;
14  float       f ;
15  double      g ;
16  long double h ;
17  
18  printf("Stampa della occupazione in memoria dei tipi standard\n") ;
19  printf("sizeof(char)        = %d\n", sizeof(char)) ;
20  printf("sizeof(int)         = %d\n", sizeof(int)) ;
21  printf("sizeof(short)       = %d\n", sizeof(short)) ;
22  printf("sizeof(long)        = %d\n", sizeof(long)) ;
23  printf("sizeof(long long)   = %d\n", sizeof(long long)) ;
24  printf("sizeof(float)       = %d\n", sizeof(float)) ;
25  printf("sizeof(double)      = %d\n", sizeof(double)) ;
26  printf("sizeof(long double) = %d\n", sizeof(long double)) ;
27
28  printf("sizeof(a) = %d\n", sizeof(a)) ;
29  printf("sizeof(b) = %d\n", sizeof(b)) ;
30  printf("sizeof(c) = %d\n", sizeof(c)) ;
31  printf("sizeof(d) = %d\n", sizeof(d)) ;
32  printf("sizeof(e) = %d\n", sizeof(e)) ;
33  printf("sizeof(f) = %d\n", sizeof(f)) ;
34  printf("sizeof(g) = %d\n", sizeof(g)) ;
35  printf("sizeof(h) = %d\n", sizeof(h)) ;
36
37  return 0 ; 
38}
39
40/*
41  per compilarlo uso su macchine UNIX
42  > gcc esempio2.c -o esempio2
43*/

Esempi di vettori e puntatori e librerie standard:

File esempio5.c

:open:
 1/* 
 2 * Esempio di vettori e puntatori
 3 *
 4 * Uso della libreria standard del C per ordinare un vettore
 5 *
 6 */
 7
 8#include <stdio.h>
 9/* per le funzioni matematiche tipo sqrt */
10#include <math.h>
11
12/* per la routine di ordinamento qsort */
13#include <stdlib.h>
14
15/*
16void
17qsort(void *base, size_t nmemb, size_t size,
18     int (*compar)(const void *, const void *));
19*/
20
21int
22compare(const void * pa_in, const void * pb_in) {
23  double const * pa = pa_in ;
24  double const * pb = pb_in ;
25  if ( *pa == *pb ) return 0 ;
26  if ( *pa >  *pb ) return 1 ;
27  return -1 ;
28}
29
30int
31main() {
32  double vec[100] ; /* definisco un vettore di double di 100 elementi */
33
34  /* riempimento del vettore */
35  { /* apro un blocco, posso definire variabili locali al blocco */
36	/* le variabili esterne tipo "vec" sono visibili nel blocco  */
37	int i=0 ;
38    int j=1231242 ;
39	while ( i < 100 ) {
40	  vec[i] = sqrt( fabs( (double)(j%1234) ) ) ;
41      j      = (j*2341) % 234245 ;
42      ++i ;
43	}
44	/* vec contiene numeri non in ordine */
45  }
46  /* stampa dei numeri */
47  {
48	int i, j ;
49	for ( i=0 ; i < 20 ; ++i ) {
50	  for ( j=0 ; j < 5 ; ++j )
51		printf("%lf, ",vec[i*5+j]) ;
52      printf("\n") ;
53	}
54  }
55
56  /* ordino i numeri con qsort */
57  qsort(vec, 100, sizeof(vec[0]), compare ) ;
58
59  printf("\n\nNumeri Ordinati\n\n") ;
60  /* stampa dei numeri */
61  {
62	int i, j ;
63	for ( i=0 ; i < 20 ; ++i ) {
64	  for ( j=0 ; j < 5 ; ++j )
65		printf("%lf, ",vec[i*5+j]) ;
66      printf("\n") ;
67	}
68  }
69
70  return 0 ; 
71}
72
73/*
74  per compilarlo uso su macchine UNIX
75  > gcc esempio2.c -o esempio2
76*/

File esempio6.c

:open:
 1/* 
 2 * Esempio di vettori e puntatori
 3 *
 4 * Uso della libreria standard del C per ordinare un vettore
 5 *
 6 */
 7
 8#include <stdio.h>
 9/* per le funzioni matematiche tipo sqrt */
10#include <math.h>
11
12/* per la routine di ordinamento qsort */
13#include <stdlib.h>
14
15/*
16void
17qsort(void *base, size_t nmemb, size_t size,
18     int (*compar)(const void *, const void *));
19*/
20
21int
22compare(const void * pa_in, const void * pb_in) {
23  double const * pa = pa_in ;
24  double const * pb = pb_in ;
25  if ( *pa == *pb ) return 0 ;
26  if ( *pa >  *pb ) return 1 ;
27  return -1 ;
28}
29
30void
31stampa( double vec[], int nelem ) {
32  int i, j ;
33  for ( i = 0 ; i < nelem ; ) {
34	for ( j = 0 ; i < nelem && j < 5 ; ++i, ++j )
35	  printf("%lf, ", vec[i]) ;
36    printf("\n") ;
37  }
38}
39
40int
41main() {
42  double * pvec ; /* definisco un puntatore al vettore */
43                  /* per convenzione uso "p" davanti a una variabile puntatore
44                     non fa parte dello standard ANSI ma delle buone abitudini
45                     di programmazione */
46
47  int nelem = 123 ; /* definisco il numero di elementi */
48
49  /* allocazione dinamica della memoria */
50  pvec = malloc( nelem * sizeof(double) ) ;
51  printf("puntatore %lX\n",(long) pvec) ;
52
53  if ( pvec == NULL ) {
54    /* allocazione dinamica fallita */	
55	printf("allocazione dinamica fallita per pvec\n") ;
56	exit(1) ; /* uscita pulita dal programma */ 	
57  }
58
59  /* riempimento del vettore */
60  { /* apro un blocco, posso definire variabili locali al blocco */
61	/* le variabili esterne tipo "vec" sono visibili nel blocco  */
62	int i=0 ;
63    int j=1231242 ;
64	while ( i < nelem ) {
65	  pvec[i] = sqrt( fabs( (double)(j%1234) ) ) ;
66      j      = (j*2341) % 234245 ;
67      ++i ;
68	}
69	/* vec contiene numeri non in ordine */
70  }
71  /* stampa dei numeri */
72  stampa( pvec, nelem ) ;
73
74  /* ordino i numeri con qsort */
75  qsort(pvec, nelem, sizeof(pvec[0]), compare ) ;
76
77  printf("\n\nNumeri Ordinati\n\n") ;
78  /* stampa dei numeri */
79  stampa( pvec, nelem ) ;
80
81  /* rilascio della memoria allocata */
82  free(pvec) ;
83
84  return 0 ; 
85}
86
87/*
88  per compilarlo uso su macchine UNIX
89  > gcc esempio6.c -o esempio6
90*/

File esempio7.c

:open:
 1/* 
 2 * Esempio di vettori e puntatori
 3 *
 4 * Uso della libreria standard del C per ordinare un vettore
 5 *
 6 */
 7
 8#include <stdio.h>
 9/* per le funzioni matematiche tipo sqrt */
10#include <math.h>
11
12/* per la routine di ordinamento qsort */
13#include <stdlib.h>
14
15/* parametrizzo il codice */
16typedef float value_type ;
17
18/* definisco una macro */
19#define VALUE_TYPE      "%f"
20#define CAST_VALUE_TYPE double
21
22/*
23void
24qsort(void *base, size_t nmemb, size_t size,
25     int (*compar)(const void *, const void *));
26*/
27
28int
29compare(const void * pa_in, const void * pb_in) {
30  value_type const * pa = pa_in ;
31  value_type const * pb = pb_in ;
32  if ( *pa == *pb ) return 0 ;
33  if ( *pa >  *pb ) return 1 ;
34  return -1 ;
35}
36
37void
38stampa( value_type vec[], int nelem ) {
39  int i, j ;
40  for ( i = 0 ; i < nelem ; ) {
41	for ( j = 0 ; i < nelem && j < 5 ; ++i, ++j )
42	  printf(VALUE_TYPE ", ", (CAST_VALUE_TYPE) vec[i]) ;
43    printf("\n") ;
44  }
45}
46
47int
48main() {
49  value_type * pvec ; /* definisco un puntatore al vettore */
50                      /* per convenzione uso "p" davanti a una variabile puntatore
51                         non fa parte dello standard ANSI ma delle buone abitudini
52                         di programmazione */
53
54  int nelem = 123 ; /* definisco il numero di elementi */
55
56  /* allocazione dinamica della memoria */
57  pvec = malloc( nelem * sizeof(value_type) ) ;
58  printf("puntatore %lX\n",(long) pvec) ;
59
60  if ( pvec == NULL ) {
61    /* allocazione dinamica fallita */	
62	printf("allocazione dinamica fallita per pvec\n") ;
63	exit(1) ; /* uscita pulita dal programma */ 	
64  }
65
66  /* riempimento del vettore */
67  { /* apro un blocco, posso definire variabili locali al blocco */
68	/* le variabili esterne tipo "vec" sono visibili nel blocco  */
69	int i=0 ;
70    int j=1231242 ;
71	while ( i < nelem ) {
72	  pvec[i] = sqrt( fabs( (value_type)(j%1234) ) ) ;
73      j      = (j*2341) % 234245 ;
74      ++i ;
75	}
76	/* vec contiene numeri non in ordine */
77  }
78  /* stampa dei numeri */
79  stampa( pvec, nelem ) ;
80
81  /* ordino i numeri con qsort */
82  qsort(pvec, nelem, sizeof(pvec[0]), compare ) ;
83
84  printf("\n\nNumeri Ordinati\n\n") ;
85  /* stampa dei numeri */
86  stampa( pvec, nelem ) ;
87
88  /* rilascio della memoria allocata */
89  free(pvec) ;
90
91  return 0 ; 
92}
93
94/*
95  per compilarlo uso su macchine UNIX
96  > gcc esempio6.c -o esempio6
97*/

File esempio8.c

:open:
  1/* 
  2 * Esempio di vettori e puntatori
  3 *
  4 * Uso della libreria standard del C per ordinare un vettore
  5 *
  6 */
  7
  8#include <stdio.h>
  9/* per le funzioni matematiche tipo sqrt */
 10#include <math.h>
 11
 12/* per la routine di ordinamento qsort */
 13#include <stdlib.h>
 14
 15struct rational {
 16  int numer ;
 17  int denom ;
 18} ;
 19
 20typedef struct rational  value_type ;
 21
 22/*
 23void
 24qsort(void *base, size_t nmemb, size_t size,
 25     int (*compar)(const void *, const void *));
 26*/
 27
 28int
 29compare(const void * pa_in, const void * pb_in) {
 30  struct rational const * pa = pa_in ;
 31  struct rational const * pb = pb_in ;
 32  /* pa -> denom == (*pa) . denom */
 33  int numer = pa -> numer * pb -> denom - pa -> denom * pb -> numer ;
 34  int denom = pa -> denom * pb -> denom ;
 35  if ( denom > 0 ) {
 36	if ( numer > 0 ) return 1 ;	
 37	if ( numer < 0 ) return -1 ;
 38  } else {
 39	if ( numer < 0 ) return 1 ;	
 40	if ( numer > 0 ) return -1 ;
 41  }
 42  return 0 ;
 43}
 44
 45void
 46stampa( struct rational vec[], int nelem ) {
 47  int i, j ;
 48  for ( i = 0 ; i < nelem ; ) {
 49	for ( j = 0 ; i < nelem && j < 3 ; ++i, ++j ) {
 50	  int   p      = vec[i] . numer ;
 51	  int   q      = vec[i] . denom ;
 52      float p_su_q = (float)p/(float)q ;
 53	  printf("(%d/%d)=%f, ", p, q, p_su_q ) ;
 54	}
 55    printf("\n") ;
 56  }
 57}
 58
 59int
 60main() {
 61  value_type * pvec ; /* definisco un puntatore al vettore */
 62                      /* per convenzione uso "p" davanti a una variabile puntatore
 63                         non fa parte dello standard ANSI ma delle buone abitudini
 64                         di programmazione */
 65
 66  int nelem = 123 ; /* definisco il numero di elementi */
 67
 68  /* allocazione dinamica della memoria */
 69  pvec = malloc( nelem * sizeof(value_type) ) ;
 70  printf("puntatore %lX\n",(long) pvec) ;
 71
 72  if ( pvec == NULL ) {
 73    /* allocazione dinamica fallita */	
 74	printf("allocazione dinamica fallita per pvec\n") ;
 75	exit(1) ; /* uscita pulita dal programma */ 	
 76  }
 77
 78  /* riempimento del vettore */
 79  { /* apro un blocco, posso definire variabili locali al blocco */
 80	/* le variabili esterne tipo "vec" sono visibili nel blocco  */
 81	int i=0 ;
 82    int j=1231242 ;
 83	while ( i < nelem ) {
 84	  pvec[i] . numer = j%1234 ;
 85	  pvec[i] . denom = (j+3)%234 ;
 86      j      = (j*2341) % 234245 ;
 87      ++i ;
 88	}
 89	/* vec contiene numeri non in ordine */
 90  }
 91  /* stampa dei numeri */
 92  stampa( pvec, nelem ) ;
 93
 94  /* ordino i numeri con qsort */
 95  qsort(pvec, nelem, sizeof(pvec[0]), compare ) ;
 96
 97  printf("\n\nNumeri Ordinati\n\n") ;
 98  /* stampa dei numeri */
 99  stampa( pvec, nelem ) ;
100
101  /* rilascio della memoria allocata */
102  free(pvec) ;
103
104  return 0 ; 
105}
106
107/*
108  per compilarlo uso su macchine UNIX
109  > gcc esempio6.c -o esempio6
110*/

File esempio9a.c

:open:
 1/* 
 2 * Esempio di vettori e puntatori
 3 *
 4 * Uso della libreria standard del C per ordinare un vettore
 5 *
 6 */
 7
 8/*
 9  nell'include usando le "" cerco il file nella directory
10  corrente o nelle directory specificate dal flag -I del compilatore
11
12  gcc -I/usr/pippo/pluto -I./libs .....
13
14*/
15
16#include "esempio9a.h"
17
18int
19main() {
20  value_type * pvec ; /* definisco un puntatore al vettore */
21                      /* per convenzione uso "p" davanti a una variabile puntatore
22                         non fa parte dello standard ANSI ma delle buone abitudini
23                         di programmazione */
24
25  int nelem = 123 ; /* definisco il numero di elementi */
26
27  /* allocazione dinamica della memoria */
28  pvec = malloc( nelem * sizeof(value_type) ) ;
29  printf("puntatore %lX\n",(long) pvec) ;
30
31  if ( pvec == NULL ) {
32    /* allocazione dinamica fallita */	
33	printf("allocazione dinamica fallita per pvec\n") ;
34	exit(1) ; /* uscita pulita dal programma */ 	
35  }
36
37  /* riempimento del vettore */
38  { /* apro un blocco, posso definire variabili locali al blocco */
39	/* le variabili esterne tipo "vec" sono visibili nel blocco  */
40	int i=0 ;
41    int j=1231242 ;
42	while ( i < nelem ) {
43	  pvec[i] . numer = j%1234 ;
44	  pvec[i] . denom = (j+3)%234 ;
45      j      = (j*2341) % 234245 ;
46      ++i ;
47	}
48	/* vec contiene numeri non in ordine */
49  }
50  /* stampa dei numeri */
51  stampa( pvec, nelem ) ;
52
53  /* ordino i numeri con qsort */
54  qsort(pvec, nelem, sizeof(pvec[0]), compare ) ;
55
56  printf("\n\nNumeri Ordinati\n\n") ;
57  /* stampa dei numeri */
58  stampa( pvec, nelem ) ;
59
60  /* rilascio della memoria allocata */
61  free(pvec) ;
62
63  return 0 ; 
64}
65
66/*
67  per compilarlo uso su macchine UNIX
68  > gcc esempio6.c -o esempio6
69*/

File esempio9b.c

:open:
 1/* 
 2 * Esempio di vettori e puntatori
 3 *
 4 * Uso della libreria standard del C per ordinare un vettore
 5 *
 6 */
 7
 8#include "esempio9a.h"
 9
10int
11compare(const void * pa_in, const void * pb_in) {
12  struct rational const * pa = pa_in ;
13  struct rational const * pb = pb_in ;
14  /* pa -> denom == (*pa) . denom */
15  int numer = pa -> numer * pb -> denom - pa -> denom * pb -> numer ;
16  int denom = pa -> denom * pb -> denom ;
17  if ( denom > 0 ) {
18	if ( numer > 0 ) return 1 ;	
19	if ( numer < 0 ) return -1 ;
20  } else {
21	if ( numer < 0 ) return 1 ;	
22	if ( numer > 0 ) return -1 ;
23  }
24  return 0 ;
25}
26
27void
28stampa( struct rational vec[], int nelem ) {
29  int i, j ;
30  for ( i = 0 ; i < nelem ; ) {
31	for ( j = 0 ; i < nelem && j < 3 ; ++i, ++j ) {
32	  int   p      = vec[i] . numer ;
33	  int   q      = vec[i] . denom ;
34      float p_su_q = (float)p/(float)q ;
35	  printf("(%d/%d)=%f, ", p, q, p_su_q ) ;
36	}
37    printf("\n") ;
38  }
39}

File esempio9a.h

:open:
 1/* 
 2 * Esempio di vettori e puntatori
 3 *
 4 * Uso della libreria standard del C per ordinare un vettore
 5 *
 6 */
 7
 8#include <stdio.h>
 9/* per le funzioni matematiche tipo sqrt */
10#include <math.h>
11
12/* per la routine di ordinamento qsort */
13#include <stdlib.h>
14
15struct rational {
16  int numer ;
17  int denom ;
18} ;
19
20typedef struct rational  value_type ;
21
22extern void stampa  ( struct rational vec[], int nelem ) ;
23extern int  compare ( const void * pa_in, const void * pb_in ) ;
24
25/* in questo caso extern a' opzionale trattandosi di prototipi
26   di funzioni */