Uso delle funzioni Uso delle funzioni

Presentazione sul tema: "Uso delle funzioni Uso delle funzioni"— Transcript della presentazione:

1 Uso delle funzioni Uso delle funzioni
Lo scopo di questa introduzione al linguaggio C++ è di discutere in dettaglio un esempio di uso di C++. 1

2 Uso delle funzioni Copyright © 1997 by Mario G. Montobbio
All rights reserved. No part of this publication may be reproduced, stored in a retrieval system, or transmitted, in any form or by any means, electronic, mechanical, photocopying, recording, or otherwise, without the prior written permission of the author. Permission to use, copy and distribute this publication for the purposes of research or private study without fee is hereby granted, provided that this copyright notice and this permission notice appear in all copies. Mario G. Montobbio

3 Funzione di partenza Funzione di partenza

4 Funzione di partenza main Valore1 = 5 Valore2 = 10 Transito = Valore 1
Costruiamo una semplice applicazione C che stampa due valori ... Valore1 = 5 Valore2 = 10 Stampa valori originali Transito = Valore 1 Valore 1 = Valore 2 Valore 2 = Transito Stampa valori scambiati end

5 Funzione di partenza main Valore1 = 5 Valore2 = 10 Transito = Valore 1
Stampa valori originali ... poi scambia i valori fra di loro ... Transito = Valore 1 Valore 1 = Valore 2 Valore 2 = Transito Stampa valori scambiati end

6 Funzione di partenza main Valore1 = 5 Valore2 = 10 Transito = Valore 1
Stampa valori originali ... poi li ri-stampa dopo lo scambio. Transito = Valore 1 Valore 1 = Valore 2 Valore 2 = Transito Stampa valori scambiati end

7 Funzione di partenza main Valore1 = 5 Valore2 = 10 Transito = Valore 1
Stampa valori originali Costruiamo due versioni di questa applicazione: la prima versione è composta da un’unica funzione main ... Transito = Valore 1 Valore 1 = Valore 2 Valore 2 = Transito Stampa valori scambiati end

8 Funzione di partenza main Valore1 = 5 Valore2 = 10 Transito = Valore 1
Stampa valori originali ... nella seconda applicazione isoliamo il passo di scampio dei valori in una funzione Scambio poiché pensiamo che in altre applicazioni ci capiterà di scambiare due valori. Transito = Valore 1 Valore 1 = Valore 2 Valore 2 = Transito Stampa valori scambiati end

9 Funzione di partenza main Valore1 = 5 Valore2 = 10 Scambio end
Stampa valori originali ... nella seconda applicazione isoliamo il passo di scampio dei valori in una funzione Scambio poiché pensiamo che in altre applicazioni ci capiterà di scambiare due valori. Scambio Stampa valori scambiati end

10 Funzione di partenza 1 #include <stdio.h> 2 main (void) 3 {
3 { 4 int aValore1 = 5; 5 int aValore2 = 10; 6 int aTransito; 7 printf 8 (“Valori originali, Val1 = %d, Val2 = %d.\n” 9 ,aValore1, aValore2); Questa è l’applicazione C in un’unica funzione main.

11 Funzione di partenza 1 #include <stdio.h> 2 main (void) 3 {
3 { 4 int aValore1 = 5; 5 int aValore2 = 10; 6 int aTransito; 7 printf 8 (“Valori originali, Val1 = %d, Val2 = %d.\n” 9 ,aValore1, aValore2); Dichiariamo un’area intera denominata aValore1 e la inizializziamo al valore 5.

12 Funzione di partenza 1 #include <stdio.h> 2 main (void) 3 {
3 { 4 int aValore1 = 5; 5 int aValore2 = 10; 6 int aTransito; 7 printf 8 (“Valori originali, Val1 = %d, Val2 = %d.\n” 9 ,aValore1, aValore2); Dichiariamo un’area intera denominata aValore2 e la inizializziamo al valore 10.

13 Funzione di partenza 1 #include <stdio.h> 2 main (void) 3 {
3 { 4 int aValore1 = 5; 5 int aValore2 = 10; 6 int aTransito; 7 printf 8 (“Valori originali, Val1 = %d, Val2 = %d.\n” 9 ,aValore1, aValore2); Riserviamo un’area intera denominata aTransito che useremo come area di transito per lo scambio dei valori.

14 Funzione di partenza 1 #include <stdio.h> 2 main (void) 3 {
3 { 4 int aValore1 = 5; 5 int aValore2 = 10; 6 int aTransito; 7 printf 8 (“Valori originali, Val1 = %d, Val2 = %d.\n” 9 ,aValore1, aValore2); Stampiamo i valori prima dello scambio.

15 Funzione di partenza theParm1 5 10 5 theParm2 aTransito ... ...
10 aTransito = aValore1; 11 aValore1 = aValore2; 12 aValore2 = aTransito; 13 printf (“Valori scambiati, Val1 = %d, Val2 = %d.\n” ,aValore1, aValore2); 16 } theParm1 1 2 5 10 5 theParm2 aTransito 3 Scambiamo i valori appoggiandone uno sull’area denominata aTransito.

16 Funzione di partenza ... ... 10 aTransito = aValore1;
10 aTransito = aValore1; 11 aValore1 = aValore2; 12 aValore2 = aTransito; 13 printf (“Valori scambiati, Val1 = %d, Val2 = %d.\n” ,aValore1, aValore2); 16 } Stampiamo i valori dopo lo scambio.

17 Compilazione Compilazione

18 Compilazione 1 home/mntmgs/clang>cc prova6.c
Abbiamo introdotto il codice simbolico in prova6.c.

19 Compilazione 1 home/mntmgs/clang>cc prova6.c
Richiamiamo il compilatore C con il comando cc.

20 Compilazione 1 home/mntmgs/clang>cc prova6.c
Dopo la compilazione otteniamo nuovamente il prompt del sistema senza che siano stati emessi messaggi di errore: vuole dire che il codice non contiene errori.

21 Elaborazione Elaborazione

22 Elaborazione 1 home/mntmgs/clang>./a.out
2 Valori originali, Val1 = 5, Val2 = 10. 3 Valori scambiati, Val1 = 10, Val2 = 5. 4 home/mntmgs/clang> Poiché non abbiamo specificato un nome scelto da noi, il compilatore ha creato un modulo caricabile-eseguibile chiamato a.out ...

23 Elaborazione 1 home/mntmgs/clang>./a.out
2 Valori originali, Val1 = 5, Val2 = 10. 3 Valori scambiati, Val1 = 10, Val2 = 5. 4 home/mntmgs/clang> ... che si trova nella directory corrente.

24 Elaborazione 1 home/mntmgs/clang>./a.out
2 Valori originali, Val1 = 5, Val2 = 10. 3 Valori scambiati, Val1 = 10, Val2 = 5. 4 home/mntmgs/clang> Richiamando il modulo caricabile-eseguibile a.out ora vengono emessi i valori prima e dopo lo scambio.

25 Isolamento dello scambio in una funzione

26 Isolamento dello scambio in una funzione
1 #include <stdio.h> 2 void Scambio (int theParm1, int theParm2) 3 { 4 int aTransito; 5 aTransito = theParm1; 6 theParm1 = theParm2; 7 theParm2 = aTransito; 8 } Questa è la funzione Scambio.

27 Isolamento dello scambio in una funzione
1 #include <stdio.h> 2 void Scambio (int theParm1, int theParm2) 3 { 4 int aTransito; 5 aTransito = theParm1; 6 theParm1 = theParm2; 7 theParm2 = aTransito; 8 } La funzione Scambio ha due argomenti formali denominati theParm1, e theParm2.

28 Isolamento dello scambio in una funzione
1 #include <stdio.h> 2 void Scambio (int theParm1, int theParm2) 3 { 4 int aTransito; 5 aTransito = theParm1; 6 theParm1 = theParm2; 7 theParm2 = aTransito; 8 } L’argomento theParm1 è di tipo int ...

29 Isolamento dello scambio in una funzione
1 #include <stdio.h> 2 void Scambio (int theParm1, int theParm2) 3 { 4 int aTransito; 5 aTransito = theParm1; 6 theParm1 = theParm2; 7 theParm2 = aTransito; 8 } ... ed anche l’argomento theParm2 è di tipo int.

30 Isolamento dello scambio in una funzione
1 #include <stdio.h> 2 void Scambio (int theParm1, int theParm2) 3 { 4 int aTransito; 5 aTransito = theParm1; 6 theParm1 = theParm2; 7 theParm2 = aTransito; 8 } La funzione Scambio non restituisce alcun valore alla funzione che l’ha richiamata.

31 Isolamento dello scambio in una funzione
1 #include <stdio.h> 2 void Scambio (int theParm1, int theParm2) 3 { 4 int aTransito; 5 aTransito = theParm1; 6 theParm1 = theParm2; 7 theParm2 = aTransito; 8 } Il corpo della funzione Scambio è compreso fra la coppia di parentesi graffe { }

32 Isolamento dello scambio in una funzione
1 #include <stdio.h> 2 void Scambio (int theParm1, int theParm2) 3 { 4 int aTransito; 5 aTransito = theParm1; 6 theParm1 = theParm2; 7 theParm2 = aTransito; 8 } Riserviamo un’area intera denominata aTransito che useremo come area di transito per lo scambio dei valori..

33 Isolamento dello scambio in una funzione
1 #include <stdio.h> 2 void Scambio (int theParm1, int theParm2) 3 { 4 int aTransito; 5 aTransito = theParm1; 6 theParm1 = theParm2; 7 theParm2 = aTransito; 8 } theParm1 1 2 5 10 5 theParm2 aTransito 3 Scambiamo i valori appoggiandone uno sull’area denominata aTransito.

34 Isolamento dello scambio in una funzione
9 main (void) 10 { 11 int aValore1 = 5; 12 int aValore2 = 10; 13 printf (“Valori originali, Val1 = %d, Val2 = %d.\n” ,aValore1, aValore2); Esaminiamo la nuova versione della funzione main.

35 Isolamento dello scambio in una funzione
9 main (void) 10 { 11 int aValore1 = 5; 12 int aValore2 = 10; 13 printf (“Valori originali, Val1 = %d, Val2 = %d.\n” ,aValore1, aValore2); Dichiariamo un’area intera denominata aValore1 e la inizializziamo al valore 5.

36 Isolamento dello scambio in una funzione
9 main (void) 10 { 11 int aValore1 = 5; 12 int aValore2 = 10; 13 printf (“Valori originali, Val1 = %d, Val2 = %d.\n” ,aValore1, aValore2); Dichiariamo un’area intera denominata aValore2 e la inizializziamo al valore 10.

37 Isolamento dello scambio in una funzione
9 main (void) 10 { 11 int aValore1 = 5; 12 int aValore2 = 10; 13 printf (“Valori originali, Val1 = %d, Val2 = %d.\n” ,aValore1, aValore2); Stampiamo i valori prima dello scambio.

38 Isolamento dello scambio in una funzione
16 Scambio (aValore1, aValore2); 17 printf (“Valori scambiati, Val1 = %d, Val2 = %d.\n” ,aValore1, aValore2); 30 } Richiamiamo la funzione Scambio ...

39 Isolamento dello scambio in una funzione
16 Scambio (aValore1, aValore2); 17 printf (“Valori scambiati, Val1 = %d, Val2 = %d.\n” ,aValore1, aValore2); 30 } ... passandole gli argomenti reali fra la coppia di parentesi tonde ( ) e separati da virgole ,

40 Isolamento dello scambio in una funzione
16 Scambio (aValore1, aValore2); 17 printf (“Valori scambiati, Val1 = %d, Val2 = %d.\n” ,aValore1, aValore2); 30 } Il primo argomento reale aValore1 ...

41 Isolamento dello scambio in una funzione
1 #include <stdio.h> 2 void Scambio (int theParm1, int theParm2) 3 { 4 int aTransito; 5 aTransito = theParm1; 6 theParm1 = theParm2; 7 theParm2 = aTransito; 8 } ... corrisponde al primo argomento formale theParm1 ...

42 Isolamento dello scambio in una funzione
16 Scambio (aValore1, aValore2); 17 printf (“Valori scambiati, Val1 = %d, Val2 = %d.\n” ,aValore1, aValore2); 30 } ... mentre il secondo argomento reale aValore2 ...

43 Isolamento dello scambio in una funzione
1 #include <stdio.h> 2 void Scambio (int theParm1, int theParm2) 3 { 4 int aTransito; 5 aTransito = theParm1; 6 theParm1 = theParm2; 7 theParm2 = aTransito; 8 } ... corrisponde al secondo argomento formale theParm2.

44 Isolamento dello scambio in una funzione
16 Scambio (aValore1, aValore2); 17 printf (“Valori scambiati, Val1 = %d, Val2 = %d.\n” ,aValore1, aValore2); 30 } Stampiamo i valori dopo lo scambio.

45 Compilazione Compilazione

46 Compilazione 1 home/mntmgs/clang>cc prova7.c
Abbiamo introdotto il codice simbolico in prova7.c.

47 Compilazione 1 home/mntmgs/clang>cc prova7.c
Richiamiamo il compilatore C con il comando cc.

48 Compilazione 1 home/mntmgs/clang>cc prova7.c
Dopo la compilazione otteniamo nuovamente il prompt del sistema senza che siano stati emessi messaggi di errore: vuole dire che il codice non contiene errori.

49 Elaborazione Elaborazione

50 Elaborazione 1 home/mntmgs/clang>./a.out
2 Valori originali, Val1 = 5, Val2 = 10. 3 Valori scambiati, Val1 = 5, Val2 = 10. 4 home/mntmgs/clang> Poiché non abbiamo specificato un nome scelto da noi, il compilatore ha creato un modulo caricabile-eseguibile chiamato a.out ...

51 Elaborazione 1 home/mntmgs/clang>./a.out
2 Valori originali, Val1 = 5, Val2 = 10. 3 Valori scambiati, Val1 = 5, Val2 = 10. 4 home/mntmgs/clang> ... che si trova nella directory corrente.

52 Elaborazione 1 home/mntmgs/clang>./a.out
2 Valori originali, Val1 = 5, Val2 = 10. 3 Valori scambiati, Val1 = 5, Val2 = 10. 4 home/mntmgs/clang> Richiamando il modulo caricabile-eseguibile a.out ora vengono emessi i valori prima e dopo lo scambio.

53 Elaborazione 1 home/mntmgs/clang>./a.out
2 Valori originali, Val1 = 5, Val2 = 10. 3 Valori scambiati, Val1 = 5, Val2 = 10. 4 home/mntmgs/clang> I valori prima e dopo lo scambio sono uguali.

54 Elaborazione ? 5 10

55 Passaggio di argomenti per valore
Passaggio argomenti per valore

56 Passaggio di argomenti per valore
16 Scambio (aValore1, aValore2); 17 printf (“Valori scambiati, Val1 = %d, Val2 = %d.\n” ,aValore1, aValore2); 30 } Il richiamo della funzione Scambio ...

57 Passaggio di argomenti per valore
16 Scambio (aValore1, aValore2); 17 printf (“Valori scambiati, Val1 = %d, Val2 = %d.\n” ,aValore1, aValore2); 30 } 2 void Scambio (int theParm1, int theParm2) 3 { 4 int aTransito; 5 aValore1 theParm1 ... valorizza theParm1 con il contenuto di aValore1 ...

58 Passaggio di argomenti per valore
16 Scambio (aValore1, aValore2); 17 printf (“Valori scambiati, Val1 = %d, Val2 = %d.\n” ,aValore1, aValore2); 30 } 2 void Scambio (int theParm1, int theParm2) 3 { 4 int aTransito; 10 aValore2 theParm2 ... e valorizza theParm2 con il contenuto di aValore2 ...

59 Passaggio di argomenti per valore
1 #include <stdio.h> 2 void Scambio (int theParm1, int theParm2) 3 { 4 int aTransito; 5 aTransito = theParm1; 6 theParm1 = theParm2; 7 theParm2 = aTransito; 8 } 1 theParm1 5 10 aValore1 5 2 5 theParm2 3 aTransito aValore2 10 La funzione Scambio scambia i valori delle aree theParm1 e theParm2 ...

60 Passaggio di argomenti per valore
9 main (void) 10 { 11 int aValore1 = 5; 12 int aValore2 = 10; 13 printf (“Valori originali, Val1 = %d, Val2 = %d.\n” ,aValore1, aValore2); 1 theParm1 5 aValore1 5 10 2 5 aValore2 10 theParm2 3 aTransito ... e non quelli delle aree di partenza aValore1 e aValore2.

61 Passaggio di argomenti per valore
1 #include <stdio.h> 2 void Scambio (int theParm1, int theParm2) 3 { 4 int aTransito; 5 aTransito = theParm1; 6 theParm1 = theParm2; 7 theParm2 = aTransito; 8 } 5 aValore1 theParm1 10 aValore2 theParm2 Gli argomenti formali theParm1 e theParm2 sono copie delle aree aValore1 ed aValore2 ...

62 Passaggio di argomenti per valore
1 #include <stdio.h> 2 void Scambio (int theParm1, int theParm2) 3 { 4 int aTransito; 5 aTransito = theParm1; 6 theParm1 = theParm2; 7 theParm2 = aTransito; 8 } theParm1 aValore1 5 theParm2 aValore2 10 ... e non “maschere” per accedere alle aree aValore1 ed aValore2.

63 Nota per i programmatori COBOL

64 Nota per i programmatori COBOL
1 IDENTIFICATION DIVISION. 2 PROGRAM-ID. “SCAMBIO”. 3 WORKING-STORAGE SECTION. A-TRANSITO PIC S9(9) COMP. 5 LINKAGE SECTION. THE-PARM1 PIC S9(9) COMP. THE-PARM2 PIC S9(9) COMP. 8 PROCEDURE DIVISION 9 USING THE-PARM1, THE-PARM2. MOVE THE-PARM1 TO A-TRANSITO. MOVE THE-PARM2 TO THE-PARM1. MOVE A-TRANSITO TO THE-PARM2. theParm1 theParm2 In COBOL gli argomenti formali sono “maschere” per accedere ...

65 Nota per i programmatori COBOL
1 IDENTIFICATION DIVISION. 2 PROGRAM-ID. “MAIN”. 3 WORKING-STORAGE SECTION. A-VALORE1 PIC S9(9) COMP VALUE +5. A-VALORE2 PIC S9(9) COMP VALUE +10. 6 PROCEDURE DIVISION. CALL “SCAMBIO” USING A-VALORE1, A-VALORE2. theParm1 +5 theParm2 +10 ... con altri nomi alle aree di partenza A-VALORE1 ed A-VALORE2.

66 Passaggio di argomenti per indirizzo
Passaggio argomenti per indirizzo

67 Passaggio di argomenti per indirizzo
1 #include <stdio.h> 2 void Scambio (int *theParm1, int *theParm2) 3 { 4 int aTransito; 5 aTransito = *theParm1; 6 *theParm1 = *theParm2; 7 *theParm2 = aTransito; 8 } In questa versione passiamo alla funzione Scambio gli indirizzi delle aree da scambiare.

68 Passaggio di argomenti per indirizzo
1 #include <stdio.h> 2 void Scambio (int *theParm1, int *theParm2) 3 { 4 int aTransito; 5 aTransito = *theParm1; 6 *theParm1 = *theParm2; 7 *theParm2 = aTransito; 8 } Gli argomenti theParm1 e theParm2 sono diventati puntatori ad aree di tipo int.

69 Passaggio di argomenti per indirizzo
16 Scambio (&aValore1, &aValore2); 17 printf (“Valori scambiati, Val1 = %d, Val2 = %d.\n” ,aValore1, aValore2); 30 } La funzione main passa alla funzione Scambio gli indirizzi delle area da scambiare e non una copia delle aree.

70 Passaggio di argomenti per indirizzo
16 Scambio (&aValore1, &aValore2); 17 printf (“Valori scambiati, Val1 = %d, Val2 = %d.\n” ,aValore1, aValore2); 30 } L’operatore & calcola l’indirizzo dell’area aValore1.

71 Passaggio di argomenti per indirizzo
1 #include <stdio.h> 2 void Scambio (int *theParm1, int *theParm2) 3 { 4 int aTransito; 5 aTransito = *theParm1; 6 *theParm1 = *theParm2; 7 *theParm2 = aTransito; 8 } ... che viene copiato nel puntatore theParm1.

72 Passaggio di argomenti per indirizzo
16 Scambio (&aValore1, &aValore2); 17 printf (“Valori scambiati, Val1 = %d, Val2 = %d.\n” ,aValore1, aValore2); 30 } L’operatore & calcola l’indirizzo dell’area aValore2.

73 Passaggio di argomenti per indirizzo
1 #include <stdio.h> 2 void Scambio (int *theParm1, int *theParm2) 3 { 4 int aTransito; 5 aTransito = *theParm1; 6 *theParm1 = *theParm2; 7 *theParm2 = aTransito; 8 } ... che viene copiato nel puntatore theParm2.

74 Passaggio di argomenti per indirizzo
1 #include <stdio.h> 2 void Scambio (int *theParm1, int *theParm2) 3 { 4 int aTransito; 5 aTransito = *theParm1; 6 *theParm1 = *theParm2; 7 *theParm2 = aTransito; 8 } Per estrarre il contenuto di aValore1 tramite il puntatore aParm1 usiamo l’operatore di de-referenziamento *

75 Passaggio di argomenti per indirizzo
1 #include <stdio.h> 2 void Scambio (int *theParm1, int *theParm2) 3 { 4 int aTransito; 5 aTransito = *theParm1; 6 *theParm1 = *theParm2; 7 *theParm2 = aTransito; 8 } 1 1 *theParm1 5 aValore1 5 10 2 5 aValore2 10 *theParm2 3 aTransito Questa dichiarazione estrae il contenuto di aValore1 e lo assegna all’area aTransito.

76 Passaggio di argomenti per indirizzo
1 #include <stdio.h> 2 void Scambio (int *theParm1, int *theParm2) 3 { 4 int aTransito; 5 aTransito = *theParm1; 6 *theParm1 = *theParm2; 7 *theParm2 = aTransito; 8 } Per estrarre il contenuto di aValore2 tramite il puntatore aParm2 usiamo l’operatore di de-referenziamento *

77 Passaggio di argomenti per indirizzo
1 #include <stdio.h> 2 void Scambio (int *theParm1, int *theParm2) 3 { 4 int aTransito; 5 aTransito = *theParm1; 6 *theParm1 = *theParm2; 7 *theParm2 = aTransito; 8 } Per assegnare un valore ad aValore1 tramite il puntatore aParm1 usiamo l’operatore di de-referenziamento *

78 Passaggio di argomenti per indirizzo
1 #include <stdio.h> 2 void Scambio (int *theParm1, int *theParm2) 3 { 4 int aTransito; 5 aTransito = *theParm1; 6 *theParm1 = *theParm2; 7 *theParm2 = aTransito; 8 } 2 1 *theParm1 5 aValore1 10 10 2 5 aValore2 10 *theParm2 3 aTransito Questa dichiarazione estrae il contenuto di aValore2 e lo assegna all’area aValore1.

79 Passaggio di argomenti per indirizzo
11 int aValore1 = 5; 12 int aValore2 = 10; 13 printf (“Valori originali, Val1 = %d, Val2 = %d.\n” ,aValore1, aValore2); 1 theParm1 5 aValore1 10 10 2 5 aValore2 10 theParm2 3 aTransito Dopo l’elaborazione di questa dichiarazione il valore dell’area aValore1 è cambiato da 5 a 10.

80 Passaggio di argomenti per indirizzo
1 #include <stdio.h> 2 void Scambio (int *theParm1, int *theParm2) 3 { 4 int aTransito; 5 aTransito = *theParm1; 6 *theParm1 = *theParm2; 7 *theParm2 = aTransito; 8 } Per assegnare un valore ad aValore2 tramite il puntatore aParm2 usiamo l’operatore di de-referenziamento *

81 Passaggio di argomenti per indirizzo
1 #include <stdio.h> 2 void Scambio (int *theParm1, int *theParm2) 3 { 4 int aTransito; 5 aTransito = *theParm1; 6 *theParm1 = *theParm2; 7 *theParm2 = aTransito; 8 } 3 1 *theParm1 5 aValore1 10 10 2 5 aValore2 5 *theParm2 3 aTransito Questa dichiarazione estrae il contenuto di aTransito e lo assegna all’area aValore2.

82 Passaggio di argomenti per indirizzo
11 int aValore1 = 5; 12 int aValore2 = 10; 13 printf (“Valori originali, Val1 = %d, Val2 = %d.\n” ,aValore1, aValore2); 1 theParm1 5 aValore1 10 10 2 5 aValore2 5 theParm2 3 aTransito Dopo l’elaborazione di questa dichiarazione il valore dell’area aValore2 è cambiato da 10 a 5.

83 Puntatori a funzioni Puntatori a funzioni

84 Puntatori a funzioni 1 #include <stdio.h>
2 void Scambio (int *theParm1, int *theParm2) 3 { 4 int aTransito; 5 aTransito = *theParm1; 6 *theParm1 = *theParm2; 7 *theParm2 = aTransito; 8 } Esaminiamo il modello della funzione Scambio ...

85 Puntatori a funzioni 1 #include <stdio.h>
2 void Scambio (int *theParm1, int *theParm2) 3 { 4 int aTransito; 5 aTransito = *theParm1; 6 *theParm1 = *theParm2; 7 *theParm2 = aTransito; 8 } ... la funzione Scambio ha due argomenti di tipo int * ...

86 Puntatori a funzioni 1 #include <stdio.h>
2 void Scambio (int *theParm1, int *theParm2) 3 { 4 int aTransito; 5 aTransito = *theParm1; 6 *theParm1 = *theParm2; 7 *theParm2 = aTransito; 8 } ... e non restituisce alcun valore.

87 Puntatori a funzioni 9 void Somma (int *theParm1, int *theParm2) 10 { 11 *theParm1 += *theParm2; 12 } Costruiamo una funzione Somma che ha lo stesso modello della funzione Scambio ...

88 Puntatori a funzioni 9 void Somma (int *theParm1, int *theParm2) 10 { 11 *theParm1 += *theParm2; 12 } ... cioè anche la funzione Somma ha due argomenti di tipo int * ...

89 Puntatori a funzioni 9 void Somma (int *theParm1, int *theParm2) 10 { 11 *theParm1 += *theParm2; 12 } ... e non restituisce alcun valore.

90 Puntatori a funzioni 9 void Somma (int *theParm1, int *theParm2) 10 { 11 *theParm1 += *theParm2; 12 } La funzione Somma estrae il contenuto di aValore2 usando il puntatore theParm2 mediante l’operatore di de-referenziamento * ...

91 Puntatori a funzioni 9 void Somma (int *theParm1, int *theParm2) 10 { 11 *theParm1 += *theParm2; 12 } ... e lo somma al contenuto di aValore1 usando il puntatore theParm1 mediante l’operatore di de-referenziamento *.

92 Puntatori a funzioni 9 void Somma (int *theParm1, int *theParm2) 10 { 11 *theParm1 += *theParm2; 12 } L’operatore += incrementa il contenuto dell’area a primo membro con il contenuto dell’area a secondo membro.

93 Puntatori a funzioni ... ... 13 main (void) 14 {
13 main (void) 14 { 15 void (*aFunction_Ptr[2]) (int *theInt1_Ptr, int *theInt2_Ptr); 17 int aValore1 = 5; 18 int aValore2 = 10; 19 int aIndex; 20 aFunction_Ptr[0] = Scambio; 21 aFunction_Ptr[1] = Somma; Costruiamo un vettore di puntatori a funzioni nel corpo della funzione main.

94 Puntatori a funzioni ... ... 13 main (void) 14 {
13 main (void) 14 { 15 void (*aFunction_Ptr[2]) (int *theInt1_Ptr, int *theInt2_Ptr); 17 int aValore1 = 5; 18 int aValore2 = 10; 19 int aIndex; 20 aFunction_Ptr[0] = Scambio; 21 aFunction_Ptr[1] = Somma; Questo è un vettore ...

95 Puntatori a funzioni ... ... 13 main (void) 14 {
13 main (void) 14 { 15 void (*aFunction_Ptr[2]) (int *theInt1_Ptr, int *theInt2_Ptr); 17 int aValore1 = 5; 18 int aValore2 = 10; 19 int aIndex; 20 aFunction_Ptr[0] = Scambio; 21 aFunction_Ptr[1] = Somma; ... che contiene due elementi.

96 Puntatori a funzioni ... ... 13 main (void) 14 {
13 main (void) 14 { 15 void (*aFunction_Ptr[2]) (int *theInt1_Ptr, int *theInt2_Ptr); 17 int aValore1 = 5; 18 int aValore2 = 10; 19 int aIndex; 20 aFunction_Ptr[0] = Scambio; 21 aFunction_Ptr[1] = Somma; Ogni elemento del vettore è un puntatore a funzione.

97 Puntatori a funzioni ... ... 13 main (void) 14 {
13 main (void) 14 { 15 void (*aFunction_Ptr[2]) (int *theInt1_Ptr, int *theInt2_Ptr); 17 int aValore1 = 5; 18 int aValore2 = 10; 19 int aIndex; 20 aFunction_Ptr[0] = Scambio; 21 aFunction_Ptr[1] = Somma; Ogni funzione puntata ha due argomenti di tipo int * ...

98 Puntatori a funzioni ... ... 13 main (void) 14 {
13 main (void) 14 { 15 void (*aFunction_Ptr[2]) (int *theInt1_Ptr, int *theInt2_Ptr); 17 int aValore1 = 5; 18 int aValore2 = 10; 19 int aIndex; 20 aFunction_Ptr[0] = Scambio; 21 aFunction_Ptr[1] = Somma; ... e non restituisce alcun valore.

99 Puntatori a funzioni ... ... 13 main (void) 14 {
13 main (void) 14 { 15 void (*aFunction_Ptr[2]) (int *theInt1_Ptr, int *theInt2_Ptr); 17 int aValore1 = 5; 18 int aValore2 = 10; 19 int aIndex; 20 aFunction_Ptr[0] = Scambio; 21 aFunction_Ptr[1] = Somma; Il primo puntatore a funzione del vettore punta alla funzione Scambio.

100 Puntatori a funzioni ... .. 13 main (void) 14 {
13 main (void) 14 { 15 void (*aFunction_Ptr[2]) (int *theInt1_Ptr, int *theInt2_Ptr); 17 int aValore1 = 5; 18 int aValore2 = 10; 19 int aIndex; 20 aFunction_Ptr[0] = Scambio; 21 aFunction_Ptr[1] = Somma; Il secondo puntatore a funzione del vettore punta alla funzione Somma.

101 Puntatori a funzioni ... ... 13 main (void) 14 {
13 main (void) 14 { 15 void (*aFunction_Ptr[2]) (int *theInt1_Ptr, int *theInt2_Ptr); 17 int aValore1 = 5; 18 int aValore2 = 10; 19 int aIndex; 20 aFunction_Ptr[0] = Scambio; 21 aFunction_Ptr[1] = Somma; Per elaborare il vettore dichiariamo un’indice che identifica l’elemento corrente.

102 Puntatori a funzioni ... ... 22 printf
22 printf ("Valori originali, Val1 = %d, Val2 = %d.\n" ,aValore1, aValore2); 25 for (aIndex = 0; aIndex < 2; ++aIndex) { aFunction_Ptr[aIndex] (&aValore1, &aValore2); printf ("Valori modificati, Val1 = %d, Val2 = %d.\n" ,aValore1, aValore2); } 32 } Stampiamo i contenuti di aValore1 ed aValore2 prima di ogni modifica.

103 Puntatori a funzioni ... ... 22 printf
22 printf ("Valori originali, Val1 = %d, Val2 = %d.\n" ,aValore1, aValore2); 25 for (aIndex = 0; aIndex < 2; ++aIndex) { aFunction_Ptr[aIndex] (&aValore1, &aValore2); printf ("Valori modificati, Val1 = %d, Val2 = %d.\n" ,aValore1, aValore2); } 32 } Richiamiamo in ciclo le funzioni puntate del vettore.

104 Puntatori a funzioni ... ... 22 printf
22 printf ("Valori originali, Val1 = %d, Val2 = %d.\n" ,aValore1, aValore2); 25 for (aIndex = 0; aIndex < 2; ++aIndex) { aFunction_Ptr[aIndex] (&aValore1, &aValore2); printf ("Valori modificati, Val1 = %d, Val2 = %d.\n" ,aValore1, aValore2); } 32 } Il ciclo inizia con il primo elemento del vettore.

105 Puntatori a funzioni ... ... 22 printf
22 printf ("Valori originali, Val1 = %d, Val2 = %d.\n" ,aValore1, aValore2); 25 for (aIndex = 0; aIndex < 2; ++aIndex) { aFunction_Ptr[aIndex] (&aValore1, &aValore2); printf ("Valori modificati, Val1 = %d, Val2 = %d.\n" ,aValore1, aValore2); } 32 } Dopo ogni ciclo incrementiamo l’indice aIndex per elaborare l’elemento seguente del vettore di puntatori.

106 Puntatori a funzioni ... ... 22 printf
22 printf ("Valori originali, Val1 = %d, Val2 = %d.\n" ,aValore1, aValore2); 25 for (aIndex = 0; aIndex < 2; ++aIndex) { aFunction_Ptr[aIndex] (&aValore1, &aValore2); printf ("Valori modificati, Val1 = %d, Val2 = %d.\n" ,aValore1, aValore2); } 32 } Il ciclo termina quando tutti gli elementi del vettore sono stati elaborati.

107 Puntatori a funzioni ... ... 22 printf
22 printf ("Valori originali, Val1 = %d, Val2 = %d.\n" ,aValore1, aValore2); 25 for (aIndex = 0; aIndex < 2; ++aIndex) { aFunction_Ptr[aIndex] (&aValore1, &aValore2); printf ("Valori modificati, Val1 = %d, Val2 = %d.\n" ,aValore1, aValore2); } 32 } Richiamiamo la funzione puntata dall’elemento corrente del vettore di puntatori a funzione.

108 Puntatori a funzioni ... ... 22 printf
22 printf ("Valori originali, Val1 = %d, Val2 = %d.\n" ,aValore1, aValore2); 25 for (aIndex = 0; aIndex < 2; ++aIndex) { aFunction_Ptr[aIndex] (&aValore1, &aValore2); printf ("Valori modificati, Val1 = %d, Val2 = %d.\n" ,aValore1, aValore2); } 32 } Stampiamo i valori dopo la modifica.

109 Compilazione Compilazione

110 Compilazione 1 home/mntmgs/clang>cc prova8.c
Abbiamo introdotto il codice simbolico in prova8.c.

111 Compilazione 1 home/mntmgs/clang>cc prova8.c
Richiamiamo il compilatore C con il comando cc.

112 Compilazione 1 home/mntmgs/clang>cc prova8.c
Dopo la compilazione otteniamo nuovamente il prompt del sistema senza che siano stati emessi messaggi di errore: vuole dire che il codice non contiene errori.

113 Elaborazione Elaborazione

114 Elaborazione 1 home/mntmgs/clang>./a.out
2 Valori originali, Val1 = 5, Val2 = 10. 3 Valori modificati, Val1 = 10, Val2 = 5. 4 Valori modificati, Val1 = 15, Val2 = 5. 5 home/mntmgs/clang> Poiché non abbiamo specificato un nome scelto da noi, il compilatore ha creato un modulo caricabile-eseguibile chiamato a.out ...

115 Elaborazione 1 home/mntmgs/clang>./a.out
2 Valori originali, Val1 = 5, Val2 = 10. 3 Valori modificati, Val1 = 10, Val2 = 5. 4 Valori modificati, Val1 = 15, Val2 = 5. 5 home/mntmgs/clang> ... che si trova nella directory corrente.

116 Elaborazione 1 home/mntmgs/clang>./a.out
2 Valori originali, Val1 = 5, Val2 = 10. 3 Valori modificati, Val1 = 10, Val2 = 5. 4 Valori modificati, Val1 = 15, Val2 = 5. 5 home/mntmgs/clang> Richiamando il modulo caricabile-eseguibile a.out ora vengono emessi i valori prima e dopo le modifiche.

117 Elaborazione 1 home/mntmgs/clang>./a.out
2 Valori originali, Val1 = 5, Val2 = 10. 3 Valori modificati, Val1 = 10, Val2 = 5. 4 Valori modificati, Val1 = 15, Val2 = 5. 5 home/mntmgs/clang> I valori dopo la prima modifica sono stati scambiati fra loro.

118 Elaborazione 22 printf ("Valori originali, Val1 = %d, Val2 = %d.\n" ,aValore1, aValore2); 25 for (aIndex = 0; aIndex < 2; ++aIndex) { aFunction_Ptr[aIndex] (&aValore1, &aValore2); printf ("Valori modificati, Val1 = %d, Val2 = %d.\n" ,aValore1, aValore2); } 32 } Quando l’indice aIndex vale 0 la funzione main richiama la funzione Scambio ...

119 Elaborazione ... ... 13 main (void) 14 { 15 void (*aFunction_Ptr[2])
13 main (void) 14 { 15 void (*aFunction_Ptr[2]) (int *theInt1_Ptr, int *theInt2_Ptr); 17 int aValore1 = 5; 18 int aValore2 = 10; 19 int aIndex; 20 aFunction_Ptr[0] = Scambio; 21 aFunction_Ptr[1] = Somma; ... poiché il primo puntatore a funzione del vettore punta alla funzione Scambio.

120 Elaborazione 1 home/mntmgs/clang>./a.out
2 Valori originali, Val1 = 5, Val2 = 10. 3 Valori modificati, Val1 = 10, Val2 = 5. 4 Valori modificati, Val1 = 15, Val2 = 5. 5 home/mntmgs/clang> Dopo la seconda modifica il contenuto di aValore1 è stato incrementato del contenuto dell’area aValore2.

121 Elaborazione 22 printf ("Valori originali, Val1 = %d, Val2 = %d.\n" ,aValore1, aValore2); 25 for (aIndex = 0; aIndex < 2; ++aIndex) { aFunction_Ptr[aIndex] (&aValore1, &aValore2); printf ("Valori modificati, Val1 = %d, Val2 = %d.\n" ,aValore1, aValore2); } 32 } Quando l’indice aIndex vale 1 la funzione main richiama la funzione Somma ...

122 Elaborazione ... ... 13 main (void) 14 { 15 void (*aFunction_Ptr[2])
13 main (void) 14 { 15 void (*aFunction_Ptr[2]) (int *theInt1_Ptr, int *theInt2_Ptr); 17 int aValore1 = 5; 18 int aValore2 = 10; 19 int aIndex; 20 aFunction_Ptr[0] = Scambio; 21 aFunction_Ptr[1] = Somma; ... poiché il secondo puntatore a funzione del vettore punta alla funzione Somma.

123 Elaborazione A cosa serve un vettore di puntatori a funzione?

124 Costruzione di oggetti

125 Costruzione di oggetti
1 struct Component_Tag 2 { 3 char* (*Is_Type) (void); 4 char* (*Displayable_Format) (void); 5 int (*Is_Container) (void); 6 void* (*Clonate) (void); 7 void (*Delete) (void); 8 }; Il linguaggio C permette di costruire un modello di aggregato che contiene solamente puntatori a funzione.

126 Costruzione di oggetti
1 struct Component_Tag 2 { 3 char* (*Is_Type) (void); 4 char* (*Displayable_Format) (void); 5 int (*Is_Container) (void); 6 void* (*Clonate) (void); 7 void (*Delete) (void); 8 }; Questi sono puntatori a funzione.

127 Costruzione di oggetti
1 struct Component_Tag 2 { 3 char* (*Is_Type) (void); 4 char* (*Displayable_Format) (void); 5 int (*Is_Container) (void); 6 void* (*Clonate) (void); 7 void (*Delete) (void); 8 }; Is_Type punta ad una funzione ...

128 Costruzione di oggetti
1 struct Component_Tag 2 { 3 char* (*Is_Type) (void); 4 char* (*Displayable_Format) (void); 5 int (*Is_Container) (void); 6 void* (*Clonate) (void); 7 void (*Delete) (void); 8 }; ... che non ha argomenti ...

129 Costruzione di oggetti
1 struct Component_Tag 2 { 3 char* (*Is_Type) (void); 4 char* (*Displayable_Format) (void); 5 int (*Is_Container) (void); 6 void* (*Clonate) (void); 7 void (*Delete) (void); 8 }; ... e restituisce un puntatore a carattere.

130 Costruzione di oggetti
1 struct Component_Tag 2 { 3 char* (*Is_Type) (void); 4 char* (*Displayable_Format) (void); 5 int (*Is_Container) (void); 6 void* (*Clonate) (void); 7 void (*Delete) (void); 8 }; Displayable_Format punta ad una funzione ...

131 Costruzione di oggetti
1 struct Component_Tag 2 { 3 char* (*Is_Type) (void); 4 char* (*Displayable_Format) (void); 5 int (*Is_Container) (void); 6 void* (*Clonate) (void); 7 void (*Delete) (void); 8 }; ... che non ha argomenti ...

132 Costruzione di oggetti
1 struct Component_Tag 2 { 3 char* (*Is_Type) (void); 4 char* (*Displayable_Format) (void); 5 int (*Is_Container) (void); 6 void* (*Clonate) (void); 7 void (*Delete) (void); 8 }; ... e restituisce un puntatore a carattere.

133 Costruzione di oggetti
1 struct Component_Tag 2 { 3 char* (*Is_Type) (void); 4 char* (*Displayable_Format) (void); 5 int (*Is_Container) (void); 6 void* (*Clonate) (void); 7 void (*Delete) (void); 8 }; Is_Container punta ad una funzione ...

134 Costruzione di oggetti
1 struct Component_Tag 2 { 3 char* (*Is_Type) (void); 4 char* (*Displayable_Format) (void); 5 int (*Is_Container) (void); 6 void* (*Clonate) (void); 7 void (*Delete) (void); 8 }; ... che non ha argomenti ...

135 Costruzione di oggetti
1 struct Component_Tag 2 { 3 char* (*Is_Type) (void); 4 char* (*Displayable_Format) (void); 5 int (*Is_Container) (void); 6 void* (*Clonate) (void); 7 void (*Delete) (void); 8 }; ... e restituisce un valore di tipo int.

136 Costruzione di oggetti
1 struct Component_Tag 2 { 3 char* (*Is_Type) (void); 4 char* (*Displayable_Format) (void); 5 int (*Is_Container) (void); 6 void* (*Clonate) (void); 7 void (*Delete) (void); 8 }; Clonate punta ad una funzione ...

137 Costruzione di oggetti
1 struct Component_Tag 2 { 3 char* (*Is_Type) (void); 4 char* (*Displayable_Format) (void); 5 int (*Is_Container) (void); 6 void* (*Clonate) (void); 7 void (*Delete) (void); 8 }; ... che non ha argomenti ...

138 Costruzione di oggetti
1 struct Component_Tag 2 { 3 char* (*Is_Type) (void); 4 char* (*Displayable_Format) (void); 5 int (*Is_Container) (void); 6 void* (*Clonate) (void); 7 void (*Delete) (void); 8 }; ... e restituisce un puntatore ad un’area di formato non specificato.

139 Costruzione di oggetti
1 struct Component_Tag 2 { 3 char* (*Is_Type) (void); 4 char* (*Displayable_Format) (void); 5 int (*Is_Container) (void); 6 void* (*Clonate) (void); 7 void (*Delete) (void); 8 }; Delete punta ad una funzione ...

140 Costruzione di oggetti
1 struct Component_Tag 2 { 3 char* (*Is_Type) (void); 4 char* (*Displayable_Format) (void); 5 int (*Is_Container) (void); 6 void* (*Clonate) (void); 7 void (*Delete) (void); 8 }; ... che non ha argomenti ...

141 Costruzione di oggetti
1 struct Component_Tag 2 { 3 char* (*Is_Type) (void); 4 char* (*Displayable_Format) (void); 5 int (*Is_Container) (void); 6 void* (*Clonate) (void); 7 void (*Delete) (void); 8 }; ... e non restituisce alcun valore.

142 Costruzione di oggetti
1 char *Type_Integer (void) 2 { 3 return "Integer"; 4 } 5 char *Type_Text (void) 6 { 7 return "Text"; 8 } La funzione Type_Integer identifica un primo tipo logico di componente rispondendo che è di tipo Integer.

143 Costruzione di oggetti
1 char *Type_Integer (void) 2 { 3 return "Integer"; 4 } 5 char *Type_Text (void) 6 { 7 return "Text"; 8 } La funzione Type_Text identifica un secondo tipo logico di componente rispondendo che è di tipo Text.

144 Costruzione di oggetti
1 main (void) 2 { 3 struct Component_Tag aComp[2]; 4 aComp[0].Is_Type = Type_Integer; 5 aComp[1].Is_Type = Type_Text; 6 int aIndex; 7 for (aIndex = 0; aIndex < 2; ++aIndex) 8 { char * aType_Ptr = aComp[aIndex].Is_Type(); printf ("Type = %s\n", aType_Ptr); } 12 } Dichiariamo un vettore di aggregati di tipo Component_Tag (nome del programmatore).

145 Costruzione di oggetti
1 main (void) 2 { 3 struct Component_Tag aComp[2]; 4 aComp[0].Is_Type = Type_Integer; 5 aComp[1].Is_Type = Type_Text; 6 int aIndex; 7 for (aIndex = 0; aIndex < 2; ++aIndex) 8 { char * aType_Ptr = aComp[aIndex].Is_Type(); printf ("Type = %s\n", aType_Ptr); } 12 } Il puntatore a funzione Is_Type del primo elemento del vettore punta alla funzione Type_Integer.

146 Costruzione di oggetti
1 main (void) 2 { 3 struct Component_Tag aComp[2]; 4 aComp[0].Is_Type = Type_Integer; 5 aComp[1].Is_Type = Type_Text; 6 int aIndex; 7 for (aIndex = 0; aIndex < 2; ++aIndex) 8 { char * aType_Ptr = aComp[aIndex].Is_Type(); printf ("Type = %s\n", aType_Ptr); } 12 } Il puntatore a funzione Is_Type del secondo elemento del vettore punta alla funzione Type_Text.

147 Costruzione di oggetti
1 main (void) 2 { 3 struct Component_Tag aComp[2]; 4 aComp[0].Is_Type = Type_Integer; 5 aComp[1].Is_Type = Type_Text; 6 int aIndex; 7 for (aIndex = 0; aIndex < 2; ++aIndex) 8 { char * aType_Ptr = aComp[aIndex].Is_Type(); printf ("Type = %s\n", aType_Ptr); } 12 } Quale funzione richiamiamo con questa dichiarazione?

148 Costruzione di oggetti
1 home/mntmgs/clang>./a.out 2 Type = Integer 3 Type = Text 4 home/mntmgs/clang> Al primo ciclo chiediamo al primo oggetto: “Tu di che tipo sei?”. Il primo oggetto risponde: “Io sono di tipo Integer”.

149 Costruzione di oggetti
1 home/mntmgs/clang>./a.out 2 Type = Integer 3 Type = Text 4 home/mntmgs/clang> Al secondo ciclo chiediamo al secondo oggetto: “Tu di che tipo sei?”. Il secondo oggetto risponde: “Io sono di tipo Text”.

150 Costruzione di oggetti
Elementary_Data_Item L’uso di aggregati di puntatori a funzioni con questo stile ci porta nella direzione del linguaggio C++. Is_Type Is_Container Displayable_Format Clonate Integer Real Text Is_Type Is_Type Is_Type Displayable_Format Displayable_Format Displayable_Format 250 1.25 Ferruccio

151 Costruzione di oggetti
Elementary_Data_Item Questo stesso esempio di aggregato è discusso usando il linguaggio C++ nel corso “Uso dei contenitori”. Is_Type Is_Container Displayable_Format Clonate Integer Real Text Is_Type Is_Type Is_Type Displayable_Format Displayable_Format Displayable_Format 250 1.25 Ferruccio

152 Uso delle funzioni Copyright © 1997 by Mario G. Montobbio
All rights reserved. No part of this publication may be reproduced, stored in a retrieval system, or transmitted, in any form or by any means, electronic, mechanical, photocopying, recording, or otherwise, without the prior written permission of the author. Permission to use, copy and distribute this publication for the purposes of research or private study without fee is hereby granted, provided that this copyright notice and this permission notice appear in all copies. Mario G. Montobbio