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

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 mailto:Mario.Montobbio@cec.eu.int

Funzione di partenza Funzione di partenza

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

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

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

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

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

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

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.

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.

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.

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.

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.

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

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

Compilazione Compilazione

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

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

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.

Elaborazione Elaborazione

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 ...

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.

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.

Isolamento dello scambio in una funzione

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.

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.

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 ...

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.

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.

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 { }

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..

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.

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

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

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

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

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

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

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

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 ...

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

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.

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

Compilazione Compilazione

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

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

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.

Elaborazione Elaborazione

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 ...

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.

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.

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.

Elaborazione ? 5 10

Passaggio di argomenti per valore Passaggio argomenti per valore

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

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

Passaggio di argomenti per valore ... ... 16 Scambio (aValore1, aValore2); 17 printf 28 (“Valori scambiati, Val1 = %d, Val2 = %d.\n” 29 ,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 ...

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 ...

Passaggio di argomenti per valore ... ... 9 main (void) 10 { 11 int aValore1 = 5; 12 int aValore2 = 10; 13 printf 14 (“Valori originali, Val1 = %d, Val2 = %d.\n” 15 ,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.

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 ...

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.

Nota per i programmatori COBOL

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

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

Passaggio di argomenti per indirizzo Passaggio argomenti per indirizzo

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.

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.

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

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

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.

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

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.

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 *

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.

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 *

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 *

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.

Passaggio di argomenti per indirizzo ... ... 11 int aValore1 = 5; 12 int aValore2 = 10; 13 printf 14 (“Valori originali, Val1 = %d, Val2 = %d.\n” 15 ,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.

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 *

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.

Passaggio di argomenti per indirizzo ... ... 11 int aValore1 = 5; 12 int aValore2 = 10; 13 printf 14 (“Valori originali, Val1 = %d, Val2 = %d.\n” 15 ,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.

Puntatori a funzioni Puntatori a funzioni

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 ...

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 * ...

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.

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 ...

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 * ...

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

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 * ...

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 *.

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.

Puntatori a funzioni ... ... 13 main (void) 14 { ... ... 13 main (void) 14 { 15 void (*aFunction_Ptr[2]) 16 (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.

Puntatori a funzioni ... ... 13 main (void) 14 { ... ... 13 main (void) 14 { 15 void (*aFunction_Ptr[2]) 16 (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 ...

Puntatori a funzioni ... ... 13 main (void) 14 { ... ... 13 main (void) 14 { 15 void (*aFunction_Ptr[2]) 16 (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.

Puntatori a funzioni ... ... 13 main (void) 14 { ... ... 13 main (void) 14 { 15 void (*aFunction_Ptr[2]) 16 (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.

Puntatori a funzioni ... ... 13 main (void) 14 { ... ... 13 main (void) 14 { 15 void (*aFunction_Ptr[2]) 16 (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 * ...

Puntatori a funzioni ... ... 13 main (void) 14 { ... ... 13 main (void) 14 { 15 void (*aFunction_Ptr[2]) 16 (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.

Puntatori a funzioni ... ... 13 main (void) 14 { ... ... 13 main (void) 14 { 15 void (*aFunction_Ptr[2]) 16 (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.

Puntatori a funzioni ... .. 13 main (void) 14 { ... .. 13 main (void) 14 { 15 void (*aFunction_Ptr[2]) 16 (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.

Puntatori a funzioni ... ... 13 main (void) 14 { ... ... 13 main (void) 14 { 15 void (*aFunction_Ptr[2]) 16 (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.

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

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

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

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

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

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

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

Compilazione Compilazione

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

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

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.

Elaborazione Elaborazione

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 ...

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.

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.

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.

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

Elaborazione ... ... 13 main (void) 14 { 15 void (*aFunction_Ptr[2]) ... ... 13 main (void) 14 { 15 void (*aFunction_Ptr[2]) 16 (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.

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.

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

Elaborazione ... ... 13 main (void) 14 { 15 void (*aFunction_Ptr[2]) ... ... 13 main (void) 14 { 15 void (*aFunction_Ptr[2]) 16 (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.

Elaborazione A cosa serve un vettore di puntatori a funzione?

Costruzione di oggetti

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.

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.

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 ...

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 ...

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.

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 ...

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 ...

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.

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 ...

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 ...

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.

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 ...

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 ...

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.

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 ...

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 ...

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.

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.

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.

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 { 9 char * aType_Ptr = aComp[aIndex].Is_Type(); 10 printf ("Type = %s\n", aType_Ptr); 11 } 12 } Dichiariamo un vettore di aggregati di tipo Component_Tag (nome del programmatore).

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 { 9 char * aType_Ptr = aComp[aIndex].Is_Type(); 10 printf ("Type = %s\n", aType_Ptr); 11 } 12 } Il puntatore a funzione Is_Type del primo elemento del vettore punta alla funzione Type_Integer.

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 { 9 char * aType_Ptr = aComp[aIndex].Is_Type(); 10 printf ("Type = %s\n", aType_Ptr); 11 } 12 } Il puntatore a funzione Is_Type del secondo elemento del vettore punta alla funzione Type_Text.

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 { 9 char * aType_Ptr = aComp[aIndex].Is_Type(); 10 printf ("Type = %s\n", aType_Ptr); 11 } 12 } Quale funzione richiamiamo con questa dichiarazione?

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”.

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”.

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

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

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 mailto:Mario.Montobbio@cec.eu.int