La presentazione è in caricamento. Aspetta per favore

La presentazione è in caricamento. Aspetta per favore

Introduzione al linguaggio C++ Costruzione di tipi di dati del programmatore.

Presentazioni simili


Presentazione sul tema: "Introduzione al linguaggio C++ Costruzione di tipi di dati del programmatore."— Transcript della presentazione:

1 Introduzione al linguaggio C++ Costruzione di tipi di dati del programmatore

2 Introduzione al linguaggio C++ Costruzione di tipi di dati del programmatore 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. Mario G. Montobbio 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.

3 Introduzione al linguaggio C++ Costruzione di tipi di dati del programmatore Linguaggi senza verifica del tipo degli argomenti

4 Introduzione al linguaggio C++ Costruzione di tipi di dati del programmatore CHIAMANTE CHIAMATO1CHIAMATO2CHIAMATO3 Il linguaggio COBOL non verifica che il tipo degli argomenti passati da un modulo CHIAMANTE ad una funzione esterna CHIAMATOx sia quello atteso.

5 Introduzione al linguaggio C++ Costruzione di tipi di dati del programmatore CHIAMANTE CHIAMATO1CHIAMATO2CHIAMATO3 In assenza di questo controllo automatico il richiamo ad una funzione esterna CHIAMATOx assomiglia ad una spina generica.

6 Introduzione al linguaggio C++ Costruzione di tipi di dati del programmatore CHIAMANTE CHIAMATO1CHIAMATO2CHIAMATO3 La spina del modulo CHIAMANTE può collegarsi con la presa della funzione CHIAMATO1.

7 Introduzione al linguaggio C++ Costruzione di tipi di dati del programmatore CHIAMANTE CHIAMATO1 CHIAMATO2CHIAMATO3 La spina del modulo CHIAMANTE e la presa della funzione CHIAMATO1 corrispondono esattamente.

8 Introduzione al linguaggio C++ Costruzione di tipi di dati del programmatore CHIAMANTE CHIAMATO1 CHIAMATO2CHIAMATO3 Questa è la situazione ideale.

9 Introduzione al linguaggio C++ Costruzione di tipi di dati del programmatore CHIAMANTE CHIAMATO1CHIAMATO2CHIAMATO3 La spina del modulo CHIAMANTE può collegarsi anche con la presa della funzione CHIAMATO2.

10 Introduzione al linguaggio C++ Costruzione di tipi di dati del programmatore CHIAMANTE CHIAMATO1 CHIAMATO2 CHIAMATO3 La spina del modulo CHIAMANTE e la presa della funzione CHIAMATO2 non corrispondono esattamente, ma – con qualche avvertenza – possono permettere il funzionamento.

11 Introduzione al linguaggio C++ Costruzione di tipi di dati del programmatore CHIAMANTE CHIAMATO1 CHIAMATO2 CHIAMATO3 Questo metodo di richiamo funziona se utilizzo solamente i primi tre denti ricevuti da CHIAMANTE...

12 Introduzione al linguaggio C++ Costruzione di tipi di dati del programmatore CHIAMANTE CHIAMATO1 CHIAMATO2 CHIAMATO3... ma può causare una fine anomala dellelaborazione se il programmatore di CHIAMATO2 utilizza il quarto dente che non ha mai ricevuto da CHIAMANTE.

13 Introduzione al linguaggio C++ Costruzione di tipi di dati del programmatore CHIAMANTE CHIAMATO1CHIAMATO2CHIAMATO3 La spina del modulo CHIAMANTE può collegarsi anche con la presa della funzione CHIAMATO3.

14 Introduzione al linguaggio C++ Costruzione di tipi di dati del programmatore CHIAMANTE CHIAMATO1CHIAMATO2 CHIAMATO3 La spina del modulo CHIAMANTE e la presa della funzione CHIAMATO2 non corrispondono esattamente, ma – con qualche avvertenza – possono permettere il funzionamento.

15 Introduzione al linguaggio C++ Costruzione di tipi di dati del programmatore CHIAMANTE CHIAMATO1CHIAMATO2 CHIAMATO3 Questo metodo di richiamo funziona se utilizzo solamente il formato del secondo dente ricevuto da CHIAMANTE...

16 Introduzione al linguaggio C++ Costruzione di tipi di dati del programmatore CHIAMANTE CHIAMATO1CHIAMATO2 CHIAMATO3... ma può causare risultati imprevedibili oppure una fine anomala dellelaborazione se il programmatore di CHIAMATO3 utilizza la punta del secondo dente che non ha mai ricevuto da CHIAMANTE.

17 Introduzione al linguaggio C++ Costruzione di tipi di dati del programmatore Riepilogo: In questa discussione abbiamo visto che: 1.Il linguaggio COBOL non verifica il tipo degli argomenti passati ad una funzione esterna. 2.È il programmatore che deve controllare manualmente che la quantità di argomenti e i loro tipi nel modulo CHIAMANTE e nella funzione CHIAMATA1 siano uguali. 3.Solamente lelaborazione dove la quantità e il tipo degli argomenti sono uguali nel CHIAMANTE e nel CHIAMATO1 è sicura. 4.Talvolta i programmatori COBOL sfruttano lassenza di verifiche sugli argomenti. 5.Solamente in casi molto particolari (es.: moduli generalizzati, quantità di argomenti variabili) è giustificato lo sfruttamento dellassenza di verifiche sugli argomenti.

18 Introduzione al linguaggio C++ Costruzione di tipi di dati del programmatore Linguaggi con verifica del tipo degli argomenti

19 Introduzione al linguaggio C++ Costruzione di tipi di dati del programmatore Chiamante Chiamato1Chiamato2Chiamato3 Il linguaggio C++ verifica che il tipo degli argomenti passati da un modulo Chiamante ad una funzione esterna Chiamatox sia quello atteso.

20 Introduzione al linguaggio C++ Costruzione di tipi di dati del programmatore Chiamante Chiamato1Chiamato2Chiamato3 In presenza di questo controllo automatico il richiamo ad una funzione esterna CHIAMATOx assomiglia ad una spina specializzata.

21 Introduzione al linguaggio C++ Costruzione di tipi di dati del programmatore Chiamante Chiamato1Chiamato2Chiamato3 La spina del modulo Chiamante può collegarsi con la presa della funzione Chiamato1.

22 Introduzione al linguaggio C++ Costruzione di tipi di dati del programmatore Chiamante Chiamato1 Chiamato2Chiamato3 La spina del modulo Chiamante e la presa della funzione Chiamato1 corrispondono esattamente.

23 Introduzione al linguaggio C++ Costruzione di tipi di dati del programmatore Chiamante Chiamato1 Chiamato2Chiamato3 Questa è la situazione ideale.

24 Introduzione al linguaggio C++ Costruzione di tipi di dati del programmatore Chiamante Chiamato1Chiamato2Chiamato3 La spina del modulo Chiamante NON può collegarsi anche con la presa della funzione Chiamato2...

25 Introduzione al linguaggio C++ Costruzione di tipi di dati del programmatore Chiamante Chiamato1Chiamato2Chiamato3... infatti il modulo Chiamante NON passa il quarto argomento atteso dalla funzione Chiamato2.

26 Introduzione al linguaggio C++ Costruzione di tipi di dati del programmatore Chiamante Chiamato1Chiamato2Chiamato3 Il richiamo dal modulo Chiamante alla funzione esterna Chiamato2 non è un richiamo sicuro Chiamante

27 Introduzione al linguaggio C++ Costruzione di tipi di dati del programmatore Chiamante Chiamato1Chiamato2Chiamato3 La spina del modulo Chiamante NON può collegarsi anche con la presa della funzione Chiamato3...

28 Introduzione al linguaggio C++ Costruzione di tipi di dati del programmatore Chiamante Chiamato1Chiamato2Chiamato3... infatti il secondo argomento passato dal modulo Chiamante NON è dello stesso tipo del secondo argomento atteso dalla funzione Chiamato3.

29 Introduzione al linguaggio C++ Costruzione di tipi di dati del programmatore Chiamante Chiamato1Chiamato2Chiamato3 Il richiamo dal modulo Chiamante alla funzione esterna Chiamato3 non è un richiamo sicuro Chiamante

30 Introduzione al linguaggio C++ Costruzione di tipi di dati del programmatore Riepilogo: In questa discussione abbiamo visto che: 1.Il linguaggio C++ verifica il tipo degli argomenti passati ad una funzione. 2.Il programmatore non deve più controllare manualmente che la quantità di argomenti e i loro tipi nel modulo Chiamante e nella funzione Chiamato1 siano uguali: ci pensa il compilatore. 3.Il linguaggio C++ permette di creare tipi di argomenti del programmatore per sfruttare la verifica del tipo degli argomenti. 4.È sicura solamente lelaborazione dove la quantità di argomenti è uguale ed i tipi degli argomenti sono uguali o compatibili nel Chiamante e nel Chiamato1. 5.I casi particolari (es.: moduli generalizzati, quantità di argomenti variabili) possono essere risolti mediante costruzioni del linguaggio C++ che non evitano il controllo dei tipi degli argomenti (es.: gerarchia tipi-sottotipi, contenitori).

31 Introduzione al linguaggio C++ Mancanza di modello delle funzioni esterne

32 Introduzione al linguaggio C++ Mancanza di modello delle funzioni esterne 1 IDENTIFICATION DIVISION. 2 PROGRAM-ID. CHIAMANTE WORKING-STORAGE SECTION REQ-AREA REQ-MAX PIC S9(9) VALUE +10 COMP. 6 * Quantity of foreseen iteration requests REQ-LIM PIC S9(9) VALUE ZERO COMP. 8 * Quantity of iteration requests in use REQ-IND PIC S9(9) VALUE ZERO COMP. 10 * Index to the current iteration request. Questo è un esempio di dichiarazione di aree nel modulo CHIAMANTE scritto in linguaggio COBOL.

33 Introduzione al linguaggio C++ Mancanza di modello delle funzioni esterne 1 IDENTIFICATION DIVISION. 2 PROGRAM-ID. CHIAMANTE WORKING-STORAGE SECTION REQ-AREA REQ-MAX PIC S9(9) VALUE +10 COMP. 6 * Quantity of foreseen iteration requests REQ-LIM PIC S9(9) VALUE ZERO COMP. 8 * Quantity of iteration requests in use REQ-IND PIC S9(9) VALUE ZERO COMP. 10 * Index to the current iteration request. Queste clausole specificano i tipi di dati delle aree...

34 Introduzione al linguaggio C++ Mancanza di modello delle funzioni esterne 1 IDENTIFICATION DIVISION. 2 PROGRAM-ID. CHIAMANTE WORKING-STORAGE SECTION REQ-AREA REQ-MAX PIC S9(9) VALUE +10 COMP. 6 * Quantity of foreseen iteration requests REQ-LIM PIC S9(9) VALUE ZERO COMP. 8 * Quantity of iteration requests in use REQ-IND PIC S9(9) VALUE ZERO COMP. 10 * Index to the current iteration request.... che hanno questi nomi (definiti dal programmatore).

35 Introduzione al linguaggio C++ Mancanza di modello delle funzioni esterne 1 IDENTIFICATION DIVISION. 2 PROGRAM-ID. CHIAMANTE CALL CHIAMATO USING REQ-MAX, 4 REQ-LIM, 5 REQ-IND Se passiamo le tre aree definite nel modulo CHIAMANTE come argomenti ad una funzione esterna CHIAMATO...

36 Introduzione al linguaggio C++ Mancanza di modello delle funzioni esterne 1 IDENTIFICATION DIVISION. 2 PROGRAM-ID. CHIAMATO LINKAGE SECTION ZZ-REQ-MAX PIC S9(9) COMP ZZ-REQ-LIM PIC S9(9) COMP ZZ-REQ-IND PIC S9(9) COMP. 7 PROCEDURE DIVISION USING ZZ-REQ-MAX, 8 ZZ-REQ-LIM, 9 ZZ-REQ-IND è il programmatore che deve manualmente verificare che in CHIAMATO lordine di definizione degli argomenti ricevuti

37 Introduzione al linguaggio C++ Mancanza di modello delle funzioni esterne 1 IDENTIFICATION DIVISION. 2 PROGRAM-ID. CHIAMANTE CALL CHIAMATO USING REQ-MAX, 4 REQ-LIM, 5 REQ-IND corrisponda a quello della chiamata a funzione esterna nel modulo CHIAMANTE

38 Introduzione al linguaggio C++ Mancanza di modello delle funzioni esterne 1 IDENTIFICATION DIVISION. 2 PROGRAM-ID. CHIAMATO LINKAGE SECTION ZZ-REQ-MAX PIC S9(9) COMP ZZ-REQ-LIM PIC S9(9) COMP ZZ-REQ-IND PIC S9(9) COMP. 7 PROCEDURE DIVISION USING ZZ-REQ-MAX, 8 ZZ-REQ-LIM, 9 ZZ-REQ-IND È il programmatore che deve manualmente verificare che in CHIAMATO i tipi degli argomenti...

39 Introduzione al linguaggio C++ Mancanza di modello delle funzioni esterne 1 IDENTIFICATION DIVISION. 2 PROGRAM-ID. CHIAMANTE WORKING-STORAGE SECTION REQ-AREA REQ-MAX PIC S9(9) VALUE +10 COMP. 6 * Quantity of foreseen iteration requests REQ-LIM PIC S9(9) VALUE ZERO COMP. 8 * Quantity of iteration requests in use REQ-IND PIC S9(9) VALUE ZERO COMP. 10 * Index to the current iteration request.... corrispondano a quelli passati dal modulo CHIAMANTE.

40 Introduzione al linguaggio C++ Mancanza di modello delle funzioni esterne 1 IDENTIFICATION DIVISION. 2 PROGRAM-ID. CHIAMATO LINKAGE SECTION ZZ-REQ-MAX PIC S9(9) COMP ZZ-REQ-LIM PIC S9(9) COMP ZZ-REQ-IND PIC S9(9) COMP. 7 PROCEDURE DIVISION USING ZZ-REQ-MAX, 8 ZZ-REQ-LIM, 9 ZZ-REQ-IND Problema: La quantità e lordine degli argomenti della funzione esterna CHIAMATO ed il loro tipo NON sono sintetizzati in un modello di funzione...

41 Introduzione al linguaggio C++ Mancanza di modello delle funzioni esterne 1 IDENTIFICATION DIVISION. 2 PROGRAM-ID. CHIAMANTE CALL CHIAMATO USING REQ-MAX, 4 REQ-LIM, 5 REQ-IND che sia disponibile durante la compilazione del modulo CHIAMANTE e che permetta al compilatore di verificare automaticamente che la quantità e lordine degli argomenti passati da CHIAMANTE a CHIAMATO

42 Introduzione al linguaggio C++ Mancanza di modello delle funzioni esterne 1 IDENTIFICATION DIVISION. 2 PROGRAM-ID. CHIAMANTE WORKING-STORAGE SECTION REQ-AREA REQ-MAX PIC S9(9) VALUE +10 COMP. 6 * Quantity of foreseen iteration requests REQ-LIM PIC S9(9) VALUE ZERO COMP. 8 * Quantity of iteration requests in use REQ-IND PIC S9(9) VALUE ZERO COMP. 10 * Index to the current iteration request.... ed i loro tipi corrispondano.

43 Introduzione al linguaggio C++ Mancanza di modello delle funzioni esterne Riepilogo: In questa discussione abbiamo visto che: 1.Il linguaggio COBOL non verifica durante la compilazione il tipo degli argomenti passati ad una funzione, poiché le funzioni esterne non hanno un modello. 2.Il programmatore deve controllare manualmente che la quantità di argomenti nel richiamo alla funzione CHIAMANTE1 nel modulo CHIAMANTE e nella lista di argomenti di CHIAMANTE1 siano uguali. 3.Il programmatore deve controllare manualmente che i tipi degli argomenti nel modulo CHIAMANTE e nel modulo CHIAMATO1 siano uguali.

44 Introduzione al linguaggio C++ Inconvenienti della mancanza di modello

45 Introduzione al linguaggio C++ Omissione di un argomento Errore Nr. 1 Omissione di un argomento

46 Introduzione al linguaggio C++ Omissione di un argomento 1 IDENTIFICATION DIVISION. 2 PROGRAM-ID. CHIAMANTE CALL CHIAMATO USING REQ-LIM, 4 REQ-IND Se per errore il programmatore omette REQ-MAX nel richiamo a CHIAMATO...

47 Introduzione al linguaggio C++ Omissione di un argomento 1 IDENTIFICATION DIVISION. 2 PROGRAM-ID. CHIAMATO LINKAGE SECTION ZZ-REQ-MAX PIC S9(9) COMP ZZ-REQ-LIM PIC S9(9) COMP ZZ-REQ-IND PIC S9(9) COMP. 7 PROCEDURE DIVISION USING ZZ-REQ-MAX, 8 ZZ-REQ-LIM, 9 ZZ-REQ-IND sarebbe comodo che il compilatore confrontasse il richiamo (in CHIAMANTE ) con il modello di CHIAMATO e ci avvertisse dellomissione dellargomento.

48 Introduzione al linguaggio C++ Omissione di un argomento 1 IDENTIFICATION DIVISION. 2 PROGRAM-ID. CHIAMANTE CALL CHIAMATO USING REQ-LIM, 4 REQ-IND Problema: Il compilatore non può segnalarci lerrore poiché CHIAMANTE non conosce il modello di CHIAMATO.

49 Introduzione al linguaggio C++ Omissione di un argomento Riepilogo: In questa discussione abbiamo visto che: 1.Il linguaggio COBOL non identifica durante la compilazione lomissione di un argomento che deve essere passato ad una funzione, poiché le funzioni esterne non hanno un modello. 2.Il programmatore deve controllare manualmente nel modulo CHIAMANTE che la quantità di argomenti nel richiamo alla funzione CHIAMATO1 sia uguale a quelli attesi dalla funzione CHIAMATO1.

50 Introduzione al linguaggio C++ Inversione di due argomenti Errore Nr. 2 Inversione di due argomenti

51 Introduzione al linguaggio C++ Inversione di due argomenti 1 IDENTIFICATION DIVISION. 2 PROGRAM-ID. CHIAMANTE CALL CHIAMATO USING REQ-LIM, 4 REQ-MAX, 5 REQ-IND Se per errore il programmatore inverte REQ-MAX e REQ-LIM nel richiamo a CHIAMATO...

52 Introduzione al linguaggio C++ Inversione di due argomenti 1 IDENTIFICATION DIVISION. 2 PROGRAM-ID. CHIAMANTE CALL CHIAMATO USING REQ-LIM, 4 REQ-MAX, 5 REQ-IND il compilatore non può segnalarci lerrore poiché CHIAMANTE non conosce il modello di CHIAMATO.

53 Introduzione al linguaggio C++ Inversione di due argomenti 1 IDENTIFICATION DIVISION. 2 PROGRAM-ID. CHIAMATO LINKAGE SECTION ZZ-REQ-MAX PIC S9(9) COMP ZZ-REQ-LIM PIC S9(9) COMP ZZ-REQ-IND PIC S9(9) COMP. 7 PROCEDURE DIVISION USING ZZ-REQ-MAX, 8 ZZ-REQ-LIM, 9 ZZ-REQ-IND In questo caso – anche se confrontassimo il richiamo col modello di CHIAMATO – linversione degli argomenti è ancora più difficile da rilevare poiché sono entrambi dello stesso tipo: PIC S9(9) COMP.

54 Introduzione al linguaggio C++ Inversione di due argomenti 1 IDENTIFICATION DIVISION. 2 PROGRAM-ID. CHIAMANTE WORKING-STORAGE SECTION REQ-AREA REQ-MAX PIC S9(9) VALUE +10 COMP. 6 * Quantity of foreseen iteration requests REQ-LIM PIC S9(9) VALUE ZERO COMP. 8 * Quantity of iteration requests in use REQ-IND PIC S9(9) VALUE ZERO COMP. 10 * Index to the current iteration request. Esaminando i nomi delle aree, notiamo che le aree rappresentano concetti diversi...

55 Introduzione al linguaggio C++ Inversione di due argomenti 1 IDENTIFICATION DIVISION. 2 PROGRAM-ID. CHIAMANTE WORKING-STORAGE SECTION REQ-AREA REQ-MAX PIC S9(9) VALUE +10 COMP. 6 * Quantity of foreseen iteration requests REQ-LIM PIC S9(9) VALUE ZERO COMP. 8 * Quantity of iteration requests in use REQ-IND PIC S9(9) VALUE ZERO COMP. 10 * Index to the current iteration request. REQ-MAX è un valore massimo...

56 Introduzione al linguaggio C++ Inversione di due argomenti 1 IDENTIFICATION DIVISION. 2 PROGRAM-ID. CHIAMANTE WORKING-STORAGE SECTION REQ-AREA REQ-MAX PIC S9(9) VALUE +10 COMP. 6 * Quantity of foreseen iteration requests REQ-LIM PIC S9(9) VALUE ZERO COMP. 8 * Quantity of iteration requests in use REQ-IND PIC S9(9) VALUE ZERO COMP. 10 * Index to the current iteration request.... mentre REQ-LIM è un valore in uso.

57 Introduzione al linguaggio C++ Inversione di due argomenti 1 IDENTIFICATION DIVISION. 2 PROGRAM-ID. CHIAMATO LINKAGE SECTION ZZ-REQ-MAX PIC S9(9) COMP ZZ-REQ-LIM PIC S9(9) COMP ZZ-REQ-IND PIC S9(9) COMP. 7 PROCEDURE DIVISION USING ZZ-REQ-MAX, 8 ZZ-REQ-LIM, 9 ZZ-REQ-IND Sarebbe utile che il compilatore ci permettesse di distinguere fra un valore massimo e un valore in uso...

58 Introduzione al linguaggio C++ Inversione di due argomenti 1 IDENTIFICATION DIVISION. 2 PROGRAM-ID. CHIAMATO LINKAGE SECTION ZZ-REQ-MAX PIC S9(9) COMP ZZ-REQ-LIM PIC S9(9) COMP ZZ-REQ-IND PIC S9(9) COMP. 7 PROCEDURE DIVISION USING ZZ-REQ-MAX, 8 ZZ-REQ-LIM, 9 ZZ-REQ-IND e confrontasse il richiamo (in CHIAMANTE ) con il modello di CHIAMATO e ci avvertisse dellinversione degli argomenti.

59 Introduzione al linguaggio C++ Inversione di due argomenti 1 IDENTIFICATION DIVISION. 2 PROGRAM-ID. CHIAMATO LINKAGE SECTION ZZ-REQ-MAX PIC S9(9) COMP ZZ-REQ-LIM PIC S9(9) COMP ZZ-REQ-IND PIC S9(9) COMP. 7 PROCEDURE DIVISION USING ZZ-REQ-MAX, 8 ZZ-REQ-LIM, 9 ZZ-REQ-IND Per distinguere automaticamente ZZ-REQ-MAX e ZZ-REQ-LIM in base al tipo di dato, dovremmo potere sostituire S9(9) COMP con un tipo di dato definito dal programmatore.

60 Introduzione al linguaggio C++ Inversione di due argomenti 1 IDENTIFICATION DIVISION. 2 PROGRAM-ID. CHIAMANTE WORKING-STORAGE SECTION REQ-AREA REQ-MAX PIC S9(9) VALUE +10 COMP. 6 * Quantity of foreseen iteration requests REQ-LIM PIC S9(9) VALUE ZERO COMP. 8 * Quantity of iteration requests in use REQ-IND PIC S9(9) VALUE ZERO COMP. 10 * Index to the current iteration request. Problema: I possibili tipi sono già pre-definiti nel linguaggio COBOL e non è possibile creare nuovi tipi definiti dal programmatore.

61 Introduzione al linguaggio C++ Costruzione di tipi di dati del programmatore Riepilogo: In questa discussione abbiamo visto che: 1.Il linguaggio COBOL non identifica durante la compilazione linversione di due argomenti passati ad una funzione, poiché le funzioni esterne non hanno un modello. 2.Il programmatore deve controllare manualmente nel modulo CHIAMANTE che la quantità di argomenti nel richiamo alla funzione CHIAMATO1 sia uguale alla quantità attesa dalla funzione CHIAMATO1. 4.Il linguaggio COBOL non permette di creare tipi di dati del programmatore, e quindi non potrebbe comunque sfruttare la verifica del tipo degli argomenti per distinguere linversione di due argomenti che hanno lo stesso tipo – PIC S9(9) COMP – pre-definito nel linguaggio. 3.Il programmatore deve controllare manualmente che i tipi degli argomenti nel modulo CHIAMANTE e nel modulo CHIAMATO1 siano uguali.

62 Introduzione al linguaggio C++ Scambio di aggregato in argomento Errore Nr. 3 Scambio di aggregato in argomento

63 Introduzione al linguaggio C++ Scambio di aggregato in argomento 1 IDENTIFICATION DIVISION. 2 PROGRAM-ID. CHIAMANTE WORKING-STORAGE SECTION REQ-AREA REQ-MAX PIC S9(9) VALUE +10 COMP. 6 * Quantity of foreseen iteration requests REQ-LIM PIC S9(9) VALUE ZERO COMP. 8 * Quantity of iteration requests in use REQ-IND PIC S9(9) VALUE ZERO COMP. 10 * Index to the current iteration request. REQ-AREA è un aggregato di aree costruito seconde le necessità del programmatore, ma non è un nuovo tipo di dato.

64 Introduzione al linguaggio C++ Scambio di aggregato in argomento 1 IDENTIFICATION DIVISION. 2 PROGRAM-ID. CHIAMANTE CALL CHIAMATO USING REQ-AREA Possiamo richiamare una versione modificata di CHIAMATO passando come argomento un aggregato REQ-AREA...

65 Introduzione al linguaggio C++ Scambio di aggregato in argomento 1 IDENTIFICATION DIVISION. 2 PROGRAM-ID. CHIAMANTE CALL CHIAMATO USING OTHER-AREA Ma se – per errore – nel richiamo a CHIAMATO il programmatore passa laggregato OTHER-AREA al posto di REQ-AREA...

66 Introduzione al linguaggio C++ Scambio di aggregato in argomento 1 IDENTIFICATION DIVISION. 2 PROGRAM-ID. CHIAMANTE CALL CHIAMATO USING OTHER-AREA il compilatore non ci può avvertire...

67 Introduzione al linguaggio C++ Scambio di aggregato in argomento 1 IDENTIFICATION DIVISION. 2 PROGRAM-ID. CHIAMANTE WORKING-STORAGE SECTION OTHER-AREA OTHER-NAME PIC X(9) 13 VALUE FERRUCCIO OTHER-ROLE PIC X(8) 15 VALUE THE BEST.... poiché – a parte lassenza di modello – anche OTHER-AREA è un aggregato di aree come REQ-AREA.

68 Introduzione al linguaggio C++ Scambio di aggregato in argomento 3 WORKING-STORAGE SECTION REQ-AREA REQ-MAX PIC S9(9) VALUE +10 COMP. 6 * Quantity of foreseen iteration requests REQ-LIM PIC S9(9) VALUE ZERO COMP. 8 * Quantity of iteration requests in use REQ-IND PIC S9(9) VALUE ZERO COMP. 10 * Index to the current iteration request OTHER-AREA OTHER-NAME PIC X(9) Problema: Nel linguaggio COBOL non è possibile creare nuovi tipi di dati aggregati definiti dal programmatore, e distinguere gli aggregati in base al loro tipo.

69 Introduzione al linguaggio C++ Scambio di aggregato in argomento Riepilogo: In questa discussione abbiamo visto che: 1.Il linguaggio COBOL non identifica durante la compilazione la sostituzione per errore di un argomenti passato ad una funzione, poiché le funzioni esterne non hanno un modello. 2.Il programmatore deve controllare manualmente nel modulo CHIAMANTE che il formato dellargomento nel richiamo alla funzione CHIAMATO sia quello atteso dalla funzione CHIAMATO. 3.Il linguaggio COBOL non permette di creare tipi di dati aggregati del programmatore, e quindi non potrebbe comunque sfruttare la verifica del tipo degli argomenti per distinguere linversione di due argomenti che siano entrambi aggregati.

70 Introduzione al linguaggio C++ Presenza di modello delle funzioni

71 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #include Chiamato.h 2 #include Maximum.h 3 #include Limit.h 4 #include Index.h 5 void Chiamante (void) 6 { 7 Maximum Req_Max(10); // Qty foreseen requests 8 Limit Req_Lim; // Qty requests in use 9 Index Req_Ind; // Index to curr. request 10 Chiamato (Req_Max, Req_Lim, Req_Ind); 11 } Questo è un esempio di dichiarazione di aree e di richiamo alla funzione Chiamato nella funzione Chiamante scritta in linguaggio C++.

72 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #include Chiamato.h 2 #include Maximum.h 3 #include Limit.h 4 #include Index.h 5 void Chiamante (void) 6 { 7 Maximum Req_Max(10); // Qty foreseen requests 8 Limit Req_Lim; // Qty requests in use 9 Index Req_Ind; // Index to curr. request 10 Chiamato (Req_Max, Req_Lim, Req_Ind); 11 } Queste clausole specificano i tipi di dati delle aree...

73 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #include Chiamato.h 2 #include Maximum.h 3 #include Limit.h 4 #include Index.h 5 void Chiamante (void) 6 { 7 Maximum Req_Max(10); // Qty foreseen requests 8 Limit Req_Lim; // Qty requests in use 9 Index Req_Ind; // Index to curr. request 10 Chiamato (Req_Max, Req_Lim, Req_Ind); 11 }... che hanno questi nomi (definiti dal programmatore).

74 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #include Chiamato.h 2 #include Maximum.h 3 #include Limit.h 4 #include Index.h 5 void Chiamante (void) 6 { 7 Maximum Req_Max(10); // Qty foreseen requests 8 Limit Req_Lim; // Qty requests in use 9 Index Req_Ind; // Index to curr. request 10 Chiamato (Req_Max, Req_Lim, Req_Ind); 11 } Se passiamo le tre aree definite nella funzione Chiamante come argomenti ad una funzione Chiamato...

75 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #include Chiamato.h 2 #include Maximum.h 3 #include Limit.h 4 #include Index.h 5 void Chiamante (void) 6 { 7 Maximum Req_Max(10); // Qty foreseen requests 8 Limit Req_Lim; // Qty requests in use 9 Index Req_Ind; // Index to curr. request 10 Chiamato (Req_Max, Req_Lim, Req_Ind); 11 }... il compilatore può automaticamente verificare che lordine di definizione degli argomenti ricevuti nel richiamo alla funzione Chiamato

76 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #include Chiamato.h 2 #include Maximum.h 3 #include Limit.h 4 #include Index.h 5 void Chiamante (void) 6 { 7 Maximum Req_Max(10); // Qty foreseen requests 8 Limit Req_Lim; // Qty requests in use 9 Index Req_Ind; // Index to curr. request 10 Chiamato (Req_Max, Req_Lim, Req_Ind); 11 }... sia uguale a quello definito nel modello delle funzione Chiamato

77 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #ifndef __CHIAMATO_H 2 // File: Chiamato.h 3 #define __CHIAMATO_H 4 void Chiamato (Maximum theMaximum 5,Limit theLimit 6,Index theIndex); 7 #endif // __CHIAMATO_H... che è contenuto nellintestazione Chiamato.h 1 2 3

78 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #include Chiamato.h 2 #include Maximum.h 3 #include Limit.h 4 #include Index.h 5 void Chiamante (void) 6 { 7 Maximum Req_Max(10); // Qty foreseen requests 8 Limit Req_Lim; // Qty requests in use 9 Index Req_Ind; // Index to curr. request 10 Chiamato (Req_Max, Req_Lim, Req_Ind); 11 } Il compilatore ricerca il tipo del primo argomento Req_Max...

79 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #include Chiamato.h 2 #include Maximum.h 3 #include Limit.h 4 #include Index.h 5 void Chiamante (void) 6 { 7 Maximum Req_Max(10); // Qty foreseen requests 8 Limit Req_Lim; // Qty requests in use 9 Index Req_Ind; // Index to curr. request 10 Chiamato (Req_Max, Req_Lim, Req_Ind); 11 }... che è dichiarato nel corpo della funzione Chiamante

80 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #include Chiamato.h 2 #include Maximum.h 3 #include Limit.h 4 #include Index.h 5 void Chiamante (void) 6 { 7 Maximum Req_Max(10); // Qty foreseen requests 8 Limit Req_Lim; // Qty requests in use 9 Index Req_Ind; // Index to curr. request 10 Chiamato (Req_Max, Req_Lim, Req_Ind); 11 }... ed è definito nellintestazione Maximum.h

81 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #ifndef __MAXIMUM_H 2 #define __MAXIMUM_H 3 class Maximum 4 {// File: Maximum.h 5 public: 6 Maximum (void); 7 Maximum (int theMaximum); 8 Maximum (Maximum &theMaximum_Ref); 9 ~Maximum (void); 10 Maximum& operator=(Maximum &theMaximum_Ref); }; 12 #endif // __MAXIMUM_H Nellintestazione Maximum.h con la parola riservata class il programmatore definisce un nuovo tipo di dato Maximum...

82 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #include Chiamato.h 2 #include Maximum.h 3 #include Limit.h 4 #include Index.h 5 void Chiamante (void) 6 { 7 Maximum Req_Max(10); // Qty foreseen requests 8 Limit Req_Lim; // Qty requests in use 9 Index Req_Ind; // Index to curr. request 10 Chiamato (Req_Max, Req_Lim, Req_Ind); 11 }... che può essere usato per dichiarare unarea di tipo Maximum nel corpo della funzione Chiamante...

83 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #ifndef __CHIAMATO_H 2 // File: Chiamato.h 3 #define __CHIAMATO_H 4 void Chiamato (Maximum theMaximum 5,Limit theLimit 6,Index theIndex); 7 #endif // __CHIAMATO_H... e può essere usato nellintestazione Chiamato.h per definire il tipo del primo argomento theMaximum della funzione Chiamato.

84 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #ifndef __CHIAMATO_H 2 // File: Chiamato.h 3 #define __CHIAMATO_H 4 void Chiamato (Maximum theMaximum 5,Limit theLimit 6,Index theIndex); 7 #endif // __CHIAMATO_H Maximum Req_Max(10); // Qty foreseen requests 9 Limit Req_Lim; // Qty requests in use 10 Index Req_Ind; // Index to curr. request 11 Chiamato (Req_Max, Req_Lim, Req_Ind); Nel modello della funzione Chiamato...

85 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #ifndef __CHIAMATO_H 2 // File: Chiamato.h 3 #define __CHIAMATO_H 4 void Chiamato (Maximum theMaximum 5,Limit theLimit 6,Index theIndex); 7 #endif // __CHIAMATO_H Maximum Req_Max(10); // Qty foreseen requests 9 Limit Req_Lim; // Qty requests in use 10 Index Req_Ind; // Index to curr. request 11 Chiamato (Req_Max, Req_Lim, Req_Ind); il primo argomento fittizio theMaximum... 1

86 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #ifndef __CHIAMATO_H 2 // File: Chiamato.h 3 #define __CHIAMATO_H 4 void Chiamato (Maximum theMaximum 5,Limit theLimit 6,Index theIndex); 7 #endif // __CHIAMATO_H Maximum Req_Max(10); // Qty foreseen requests 9 Limit Req_Lim; // Qty requests in use 10 Index Req_Ind; // Index to curr. request 11 Chiamato (Req_Max, Req_Lim, Req_Ind); è di tipo Maximum... 12

87 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #ifndef __CHIAMATO_H 2 // File: Chiamato.h 3 #define __CHIAMATO_H 4 void Chiamato (Maximum theMaximum 5,Limit theLimit 6,Index theIndex); 7 #endif // __CHIAMATO_H Maximum Req_Max(10); // Qty foreseen requests 9 Limit Req_Lim; // Qty requests in use 10 Index Req_Ind; // Index to curr. request 11 Chiamato (Req_Max, Req_Lim, Req_Ind); e corrisponde allargomento reale Req_Max

88 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #ifndef __CHIAMATO_H 2 // File: Chiamato.h 3 #define __CHIAMATO_H 4 void Chiamato (Maximum theMaximum 5,Limit theLimit 6,Index theIndex); 7 #endif // __CHIAMATO_H Maximum Req_Max(10); // Qty foreseen requests 9 Limit Req_Lim; // Qty requests in use 10 Index Req_Ind; // Index to curr. request 11 Chiamato (Req_Max, Req_Lim, Req_Ind); che è dichiarato nel corpo della funzione Chiamante

89 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #ifndef __CHIAMATO_H 2 // File: Chiamato.h 3 #define __CHIAMATO_H 4 void Chiamato (Maximum theMaximum 5,Limit theLimit 6,Index theIndex); 7 #endif // __CHIAMATO_H Maximum Req_Max(10); // Qty foreseen requests 9 Limit Req_Lim; // Qty requests in use 10 Index Req_Ind; // Index to curr. request 11 Chiamato (Req_Max, Req_Lim, Req_Ind); di tipo Maximum

90 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #ifndef __CHIAMATO_H 2 // File: Chiamato.h 3 #define __CHIAMATO_H 4 void Chiamato (Maximum theMaximum 5,Limit theLimit 6,Index theIndex); 7 #endif // __CHIAMATO_H Maximum Req_Max(10); // Qty foreseen requests 9 Limit Req_Lim; // Qty requests in use 10 Index Req_Ind; // Index to curr. request 11 Chiamato (Req_Max, Req_Lim, Req_Ind); Poiché largomento reale Req_Max e quello formale theMaximum appartengono allo stesso tipo di dato Maximum

91 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #ifndef __CHIAMATO_H 2 // File: Chiamato.h 3 #define __CHIAMATO_H 4 void Chiamato (Maximum theMaximum 5,Limit theLimit 6,Index theIndex); 7 #endif // __CHIAMATO_H Maximum Req_Max(10); // Qty foreseen requests 9 Limit Req_Lim; // Qty requests in use 10 Index Req_Ind; // Index to curr. request 11 Chiamato (Req_Max, Req_Lim, Req_Ind); è possibile passare Req_Max come primo argomento alla funzione Chiamato

92 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #ifndef __CHIAMATO_H 2 // File: Chiamato.h 3 #define __CHIAMATO_H 4 void Chiamato (Maximum theMaximum 5,Limit theLimit 6,Index theIndex); 7 #endif // __CHIAMATO_H Maximum Req_Max(10); // Qty foreseen requests 9 Limit Req_Lim; // Qty requests in use 10 Index Req_Ind; // Index to curr. request 11 Chiamato (Req_Max, Req_Lim, Req_Ind); Analogamente il secondo argomento reale Req_Lim passato alla funzione Chiamato...

93 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #ifndef __CHIAMATO_H 2 // File: Chiamato.h 3 #define __CHIAMATO_H 4 void Chiamato (Maximum theMaximum 5,Limit theLimit 6,Index theIndex); 7 #endif // __CHIAMATO_H Maximum Req_Max(10); // Qty foreseen requests 9 Limit Req_Lim; // Qty requests in use 10 Index Req_Ind; // Index to curr. request 11 Chiamato (Req_Max, Req_Lim, Req_Ind); è dichiarato nel corpo della funzione Chiamante

94 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #ifndef __CHIAMATO_H 2 // File: Chiamato.h 3 #define __CHIAMATO_H 4 void Chiamato (Maximum theMaximum 5,Limit theLimit 6,Index theIndex); 7 #endif // __CHIAMATO_H Maximum Req_Max(10); // Qty foreseen requests 9 Limit Req_Lim; // Qty requests in use 10 Index Req_Ind; // Index to curr. request 11 Chiamato (Req_Max, Req_Lim, Req_Ind); ed è di tipo Limit

95 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #ifndef __CHIAMATO_H 2 // File: Chiamato.h 3 #define __CHIAMATO_H 4 void Chiamato (Maximum theMaximum 5,Limit theLimit 6,Index theIndex); 7 #endif // __CHIAMATO_H Maximum Req_Max(10); // Qty foreseen requests 9 Limit Req_Lim; // Qty requests in use 10 Index Req_Ind; // Index to curr. request 11 Chiamato (Req_Max, Req_Lim, Req_Ind); proprio come il secondo argomento formale theLimit nel modello della funzione Chiamato

96 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #include Chiamato.h 2 #include Maximum.h 3 #include Limit.h 4 #include Index.h 5 void Chiamante (void) 6 { 7 Maximum Req_Max(10); // Qty foreseen requests 8 Limit Req_Lim; // Qty requests in use 9 Index Req_Ind; // Index to curr. request 10 Chiamato (Req_Max, Req_Lim, Req_Ind); 11 } Il tipo di dato del programmatore Limit è definito nellintestazione Limit.h...

97 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #ifndef __LIMIT_H 2 #define __LIMIT_H 3 class Limit 4 {// File: Limit.h 5 public: 6 Limit (void); 7 Limit (int theLimit); 8 Limit (Limit &theLimit_Ref); 9 ~Limit (void); 10 Limit& operator=(Limit &theLimit_Ref); }; 12 #endif // __LIMIT_H... con la parola riservata class seguita dal nome del nuovo tipo di dato Limit.

98 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #ifndef __CHIAMATO_H 2 // File: Chiamato.h 3 #define __CHIAMATO_H 4 void Chiamato (Maximum theMaximum 5,Limit theLimit 6,Index theIndex); 7 #endif // __CHIAMATO_H Maximum Req_Max(10); // Qty foreseen requests 9 Limit Req_Lim; // Qty requests in use 10 Index Req_Ind; // Index to curr. request 11 Chiamato (Req_Max, Req_Lim, Req_Ind); Poiché largomento reale Req_Lim e quello formale theLimit appartengono allo stesso tipo di dato Limit

99 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #ifndef __CHIAMATO_H 2 // File: Chiamato.h 3 #define __CHIAMATO_H 4 void Chiamato (Maximum theMaximum 5,Limit theLimit 6,Index theIndex); 7 #endif // __CHIAMATO_H Maximum Req_Max(10); // Qty foreseen requests 9 Limit Req_Lim; // Qty requests in use 10 Index Req_Ind; // Index to curr. request 11 Chiamato (Req_Max, Req_Lim, Req_Ind); è possibile passare Req_Lim come secondo argomento alla funzione Chiamato

100 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #ifndef __CHIAMATO_H 2 // File: Chiamato.h 3 #define __CHIAMATO_H 4 void Chiamato (Maximum theMaximum 5,Limit theLimit 6,Index theIndex); 7 #endif // __CHIAMATO_H Maximum Req_Max(10); // Qty foreseen requests 9 Limit Req_Lim; // Qty requests in use 10 Index Req_Ind; // Index to curr. request 11 Chiamato (Req_Max, Req_Lim, Req_Ind); Analogamente il terzo argomento reale Req_Ind passato alla funzione Chiamato...

101 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #ifndef __CHIAMATO_H 2 // File: Chiamato.h 3 #define __CHIAMATO_H 4 void Chiamato (Maximum theMaximum 5,Limit theLimit 6,Index theIndex); 7 #endif // __CHIAMATO_H Maximum Req_Max(10); // Qty foreseen requests 9 Limit Req_Lim; // Qty requests in use 10 Index Req_Ind; // Index to curr. request 11 Chiamato (Req_Max, Req_Lim, Req_Ind); è dichiarato nel corpo della funzione Chiamante

102 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #ifndef __CHIAMATO_H 2 // File: Chiamato.h 3 #define __CHIAMATO_H 4 void Chiamato (Maximum theMaximum 5,Limit theLimit 6,Index theIndex); 7 #endif // __CHIAMATO_H Maximum Req_Max(10); // Qty foreseen requests 9 Limit Req_Lim; // Qty requests in use 10 Index Req_Ind; // Index to curr. request 11 Chiamato (Req_Max, Req_Lim, Req_Ind); ed è di tipo Index

103 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #ifndef __CHIAMATO_H 2 // File: Chiamato.h 3 #define __CHIAMATO_H 4 void Chiamato (Maximum theMaximum 5,Limit theLimit 6,Index theIndex); 7 #endif // __CHIAMATO_H Maximum Req_Max(10); // Qty foreseen requests 9 Limit Req_Lim; // Qty requests in use 10 Index Req_Ind; // Index to curr. request 11 Chiamato (Req_Max, Req_Lim, Req_Ind); proprio come il terzo argomento formale theIndex nel modello della funzione Chiamato

104 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #include Chiamato.h 2 #include Maximum.h 3 #include Limit.h 4 #include Index.h 5 void Chiamante (void) 6 { 7 Maximum Req_Max(10); // Qty foreseen requests 8 Limit Req_Lim; // Qty requests in use 9 Index Req_Ind; // Index to curr. request 10 Chiamato (Req_Max, Req_Lim, Req_Ind); 11 } Il tipo di dato del programmatore Index è definito nellintestazione Index.h...

105 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #ifndef __INDEX_H 2 #define __INDEX_H 3 class Index 4 {// File: Index.h 5 public: 6 Index (void); 7 Index (int theIndex); 8 Index (Limit &theIndex_Ref); 9 ~Index (void); 10 Index& operator=(Index &theIndex_Ref); }; 12 #endif // __INDEX_H... con la parola riservata class seguita dal nome del nuovo tipo di dato Index.

106 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #ifndef __CHIAMATO_H 2 // File: Chiamato.h 3 #define __CHIAMATO_H 4 void Chiamato (Maximum theMaximum 5,Limit theLimit 6,Index theIndex); 7 #endif // __CHIAMATO_H Maximum Req_Max(10); // Qty foreseen requests 9 Limit Req_Lim; // Qty requests in use 10 Index Req_Ind; // Index to curr. request 11 Chiamato (Req_Max, Req_Lim, Req_Ind); Poiché largomento reale Req_Ind e quello formale theIndex appartengono allo stesso tipo di dato Index

107 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #ifndef __CHIAMATO_H 2 // File: Chiamato.h 3 #define __CHIAMATO_H 4 void Chiamato (Maximum theMaximum 5,Limit theLimit 6,Index theIndex); 7 #endif // __CHIAMATO_H Maximum Req_Max(10); // Qty foreseen requests 9 Limit Req_Lim; // Qty requests in use 10 Index Req_Ind; // Index to curr. request 11 Chiamato (Req_Max, Req_Lim, Req_Ind); è possibile passare Req_Ind come terzo argomento alla funzione Chiamato

108 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #ifndef __MAXIMUM_H 2 #define __MAXIMUM_H 3 class Maximum 4 {// File: Maximum.h 5 public: 6 Maximum (void); 7 Maximum (int theMaximum); 8 Maximum (Maximum &theMaximum_Ref); 9 ~Maximum (void); 10 Maximum& operator=(Maximum &theMaximum_Ref); }; 12 #endif // __MAXIMUM_H Nellintestazione Maximum.h con la parola riservata class il programmatore definisce la forma del primo dente. Chiamante Chiamato

109 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #ifndef __LIMIT_H 2 #define __LIMIT_H 3 class Limit 4 {// File: Limit.h 5 public: 6 Limit (void); 7 Limit (int theLimit); 8 Limit (Limit &theLimit_Ref); 9 ~Limit (void); 10 Limit& operator=(Limit &theLimit_Ref); }; 12 #endif // __LIMIT_H Nellintestazione Limit.h con la parola riservata class il programmatore definisce la forma del secondo dente. Chiamante Chiamato

110 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #ifndef __INDEX_H 2 #define __INDEX_H 3 class Index 4 {// File: Index.h 5 public: 6 Index (void); 7 Index (int theIndex); 8 Index (Limit &theIndex_Ref); 9 ~Index (void); 10 Index& operator=(Index &theIndex_Ref); }; 12 #endif // __INDEX_H Nellintestazione Index.h con la parola riservata class il programmatore definisce la forma del terzo dente. Chiamante Chiamato

111 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #include Chiamato.h 2 #include Maximum.h 3 #include Limit.h 4 #include Index.h 5 void Chiamante (void) 6 { 7 Maximum Req_Max(10); // Qty foreseen requests 8 Limit Req_Lim; // Qty requests in use 9 Index Req_Ind; // Index to curr. request 10 Chiamato (Req_Max, Req_Lim, Req_Ind); 11 } Lordine dei tre argomenti nel richiamo a Chiamato definisce lordine dei denti nella spina Chiamante. Chiamante Chiamato

112 Introduzione al linguaggio C++ Presenza di modello delle funzioni 1 #ifndef __CHIAMATO_H 2 // File: Chiamato.h 3 #define __CHIAMATO_H 4 void Chiamato (Maximum theMaximum 5,Limit theLimit 6,Index theIndex); 7 #endif // __CHIAMATO_H Lordine dei tre argomenti nel modello della funzione Chiamato definisce lordine dei denti nella presa Chiamato. Chiamante Chiamato

113 Introduzione al linguaggio C++ Presenza di modello delle funzioni void Chiamato (Maximum theMaximum 5,Limit theLimit 6,Index theIndex); Maximum Req_Max(10); // Qty foreseen requests 9 Limit Req_Lim; // Qty requests in use 10 Index Req_Ind; // Index to curr. request 11 Chiamato (Req_Max, Req_Lim, Req_Ind); Le forme della spina Chiamante e della presa Chiamato corrispondono esattamente. Chiamante Chiamato

114 Introduzione al linguaggio C++ Omissione di un argomento Errore Nr. 1 Omissione di un argomento

115 Introduzione al linguaggio C++ Omissione di un argomento 1 #include Chiamato.h 2 #include Maximum.h 3 #include Limit.h 4 #include Index.h 5 void Chiamante (void) 6 { 7 Maximum Req_Max(10); // Qty foreseen requests 8 Limit Req_Lim; // Qty requests in use 9 Index Req_Ind; // Index to curr. request 10 Chiamato (Req_Lim, Req_Ind); 11 } Il compilatore può automaticamente verificare che la quantità degli argomenti ricevuti nel richiamo alla funzione Chiamato... 12

116 Introduzione al linguaggio C++ Omissione di un argomento 1 #ifndef __CHIAMATO_H 2 // File: Chiamato.h 3 #define __CHIAMATO_H 4 void Chiamato (Maximum theMaximum 5,Limit theLimit 6,Index theIndex); 7 #endif // __CHIAMATO_H... non corrisponde nellintestazione Chiamato.h alla quantità di argomenti definiti nel modello della funzione Chiamato

117 Introduzione al linguaggio C++ Inversione di due argomenti Errore Nr. 2 Inversione di due argomenti

118 Introduzione al linguaggio C++ Inversione di due argomenti 1 #include Chiamato.h 2 #include Maximum.h 3 #include Limit.h 4 #include Index.h 5 void Chiamante (void) 6 { 7 Maximum Req_Max(10); // Qty foreseen requests 8 Limit Req_Lim; // Qty requests in use 9 Index Req_Ind; // Index to curr. request 10 Chiamato (Req_Lim, Req_Max, Req_Ind); 11 } Se per errore il programmatore inverte Req_Max e Req_Lim nel richiamo a Chiamato... ABC

119 Introduzione al linguaggio C++ Inversione di due argomenti 1 #ifndef __CHIAMATO_H 2 // File: Chiamato.h 3 #define __CHIAMATO_H 4 void Chiamato (Maximum theMaximum 5,Limit theLimit 6,Index theIndex); 7 #endif // __CHIAMATO_H... il compilatore può automaticamente verificare che i tipi del primo e del secondo argomento ricevuti nel richiamo alla funzione Chiamato non corrispondono nellintestazione Chiamato.h ai tipi degli argomenti definiti nel modello della funzione Chiamato. A B C

120 Introduzione al linguaggio C++ Scambio di aggregato in argomento Errore Nr. 3 Scambio di aggregato in argomento

121 Introduzione al linguaggio C++ Scambio di aggregato in argomento 1 #include Chiamato.h 2 #include Maximum.h 3 #include Limit.h 4 #include Index.h 5 void Chiamante (void) 6 { 7 Maximum Req_Max(10); // Qty foreseen requests 8 Limit Req_Lim; // Qty requests in use 9 Index Req_Ind; // Index to curr. request 10 Chiamato (Req_Lim, Req_Max, Req_Ind); 11 } Poiché il compilatore C++ distingue fra i tipi degli aggregati lerrore Nr. 3 viene riconosciuto esattamente come lerrore Nr. 2. ABC

122 Introduzione al linguaggio C++ Scambio di aggregato in argomento 1 #ifndef __CHIAMATO_H 2 // File: Chiamato.h 3 #define __CHIAMATO_H 4 void Chiamato (Maximum theMaximum 5,Limit theLimit 6,Index theIndex); 7 #endif // __CHIAMATO_H Il compilatore può automaticamente verificare se i tipi degli argomenti ricevuti nel richiamo alla funzione Chiamato corrispondono nellintestazione Chiamato.h ai tipi degli argomenti definiti nel modello della funzione Chiamato. A B C

123 Introduzione al linguaggio C++ Componenti di un dato del programmatore

124 Introduzione al linguaggio C++ Componenti di un dato del programmatore Ci sono alcuni componenti di servizio che compaiono frequentemente nei tipi di dati definito dal programmatore. Inizializzazione minima Inizializzazioni migliori Dato_del_programmatore Inizializzazione per copia Rilascio risorse impegnate Assegnazione Copia (ad uso privato) Rilascio (ad uso privato)

125 Introduzione al linguaggio C++ Componenti di un dato del programmatore Il metodo di inizializzazione minima ci permette di costruire un dato valido del tipo definito dal programmatore senza conoscere alcun valore. Inizializzazione minima Inizializzazioni migliori Dato_del_programmatore Inizializzazione per copia Rilascio risorse impegnate Assegnazione Copia (ad uso privato) Rilascio (ad uso privato) 1

126 Introduzione al linguaggio C++ Componenti di un dato del programmatore I metodi di inizializzazione migliori ci permettono di costruire un dato del tipo definito dal programmatore partendo da valori in argomento. Inizializzazione minima Inizializzazioni migliori Dato_del_programmatore Inizializzazione per copia Rilascio risorse impegnate Assegnazione Copia (ad uso privato) Rilascio (ad uso privato) 2

127 Introduzione al linguaggio C++ Componenti di un dato del programmatore Il metodo di inizializzazione per copia ci permette di passare un dato ad una funzione e di farcelo restituire da una funzione. Inizializzazione minima Inizializzazioni migliori Dato_del_programmatore Inizializzazione per copia Rilascio risorse impegnate Assegnazione Copia (ad uso privato) Rilascio (ad uso privato) 3

128 Introduzione al linguaggio C++ Componenti di un dato del programmatore Il metodo di rilascio delle risorse permette di liberare le aree occupate dal tipo di dato e di rilasciare le risorse impegnate dai metodi di inizializzazione. Inizializzazione minima Inizializzazioni migliori Dato_del_programmatore Inizializzazione per copia Rilascio risorse impegnate Assegnazione Copia (ad uso privato) Rilascio (ad uso privato) 4

129 Introduzione al linguaggio C++ Componenti di un dato del programmatore Il metodo di assegnazione permette di assegnare un dato del tipo definito dal programmatore ad un altro dato dello stesso tipo. Inizializzazione minima Inizializzazioni migliori Dato_del_programmatore Inizializzazione per copia Rilascio risorse impegnate Assegnazione Copia (ad uso privato) Rilascio (ad uso privato) 5

130 Introduzione al linguaggio C++ Componenti di un dato del programmatore Un metodo di copia (ad uso interno) viene richiamato dal metodo di inizializzazione per copia e dal metodo di assegnazione. Inizializzazione minima Inizializzazioni migliori Dato_del_programmatore Inizializzazione per copia Rilascio risorse impegnate Assegnazione Copia (ad uso privato) Rilascio (ad uso privato) 6

131 Introduzione al linguaggio C++ Componenti di un dato del programmatore Un metodo di rilascio (ad uso interno) viene richiamato dal metodo (pubblico) di rilascio delle risorse impegnate e dal metodo di assegnazione. Inizializzazione minima Inizializzazioni migliori Dato_del_programmatore Inizializzazione per copia Rilascio risorse impegnate Assegnazione Copia (ad uso privato) Rilascio (ad uso privato) 7

132 Introduzione al linguaggio C++ Inizializzazione minima

133 Introduzione al linguaggio C++ Inizializzazione minima Il metodo di inizializzazione minima ci permette di costruire un dato valido del tipo definito dal programmatore senza conoscere alcun valore. Inizializzazione minima Inizializzazioni migliori Dato_del_programmatore Inizializzazione per copia Rilascio risorse impegnate Assegnazione Copia (ad uso privato) Rilascio (ad uso privato) 1

134 Introduzione al linguaggio C++ Inizializzazione minima 1 #include Chiamato.h 2 #include Maximum.h 3 #include Limit.h 4 #include Index.h 5 void Chiamante (void) 6 { 7 Maximum Req_Max(10); // Qty foreseen requests 8 Limit Req_Lim; // Qty requests in use 9 Index Req_Ind; // Index to curr. request 10 Chiamato (Req_Max, Req_Lim, Req_Ind); 11 } Questo è un esempio di dichiarazione minima di un dato Req_Lim di tipo Limit (definito dal programmatore)...

135 Introduzione al linguaggio C++ Inizializzazione minima 1 #ifndef __LIMIT_H 2 #define __LIMIT_H 3 class Limit 4 {// File: Limit.h 5 public: 6 Limit (void); 7 Limit (int theLimit); 8 Limit (Limit &theLimit_Ref); 9 ~Limit (void); 10 Limit& operator=(Limit &theLimit_Ref); }; 12 #endif // __LIMIT_H... e questo è il metodo che viene richiamato per inizializzare il dato di tipo Limit.

136 Introduzione al linguaggio C++ Inizializzazione minima 1 #ifndef __LIMIT_H 2 #define __LIMIT_H 3 class Limit 4 {// File: Limit.h 5 public: 6 Limit (void); 7 Limit (int theLimit); 8 Limit (Limit &theLimit_Ref); 9 ~Limit (void); 10 Limit& operator=(Limit &theLimit_Ref); }; 12 #endif // __LIMIT_H Poiché non partiamo da argomenti di nessun tipo non possiamo che inizializzare il dato con valori minimi validi.

137 Introduzione al linguaggio C++ Inizializzazioni migliori

138 Introduzione al linguaggio C++ Inizializzazioni migliori I metodi di inizializzazione migliori ci permettono di costruire un dato del tipo definito dal programmatore partendo da valori in argomento. Inizializzazione minima Inizializzazioni migliori Dato_del_programmatore Inizializzazione per copia Rilascio risorse impegnate Assegnazione Copia (ad uso privato) Rilascio (ad uso privato) 2

139 Introduzione al linguaggio C++ Inizializzazioni migliori 1 #include Chiamato.h 2 #include Maximum.h 3 #include Limit.h 4 #include Index.h 5 void Chiamante (void) 6 { 7 Maximum Req_Max(10); // Qty foreseen requests 8 Limit Req_Lim; // Qty requests in use 9 Index Req_Ind; // Index to curr. request 10 Chiamato (Req_Max, Req_Lim, Req_Ind); 11 } Questo è un esempio di dichiarazione migliore di un dato Req_Max di tipo Maximum (definito dal programmatore)...

140 Introduzione al linguaggio C++ Inizializzazioni migliori 1 #ifndef __MAXIMUM_H 2 #define __MAXIMUM_H 3 class Maximum 4 {// File: Maximum.h 5 public: 6 Maximum (void); 7 Maximum (int theMaximum); 8 Maximum (Limit &theMaximum_Ref); 9 ~Maximum (void); 10 Maximum& operator=(Maximum &theMaximum_Ref); }; 12 #endif // __MAXIMUM_H... e questo è il metodo che viene richiamato per inizializzare il dato di tipo Maximum.

141 Introduzione al linguaggio C++ Inizializzazione per copia

142 Introduzione al linguaggio C++ Inizializzazione per copia Il metodo di inizializzazione per copia ci permette di passare un dato ad una funzione e di farcelo restituire da una funzione. Inizializzazione minima Inizializzazioni migliori Dato_del_programmatore Inizializzazione per copia Rilascio risorse impegnate Assegnazione Copia (ad uso privato) Rilascio (ad uso privato) 3

143 Introduzione al linguaggio C++ Inizializzazione per copia 1 #include Chiamato.h 2 #include Maximum.h 3 #include Limit.h 4 #include Index.h 5 void Chiamante (void) 6 { 7 Maximum Req_Max(10); // Qty foreseen requests 8 Limit Req_Lim; // Qty requests in use 9 Index Req_Ind; // Index to curr. request 10 Chiamato (Req_Max, Req_Lim, Req_Ind); 11 } Questo è un esempio di passaggio di un dato Req_Max di tipo Maximum (definito dal programmatore) in argomento alla funzione Chiamato.

144 Introduzione al linguaggio C++ Inizializzazione per copia 1 #include Chiamato.h 2 #include Maximum.h 3 #include Limit.h 4 #include Index.h 5 void Chiamante (void) 6 { 7 Maximum Req_Max(10); // Qty foreseen requests 8 Limit Req_Lim; // Qty requests in use 9 Index Req_Ind; // Index to curr. request 10 Chiamato (Req_Max, Req_Lim, Req_Ind); 11 } Il compilatore richiama automaticamente il metodo di inizializzazione per copia specifico per il tipo di dato Maximum per creare largomento da passare alla funzione Chiamato.

145 Introduzione al linguaggio C++ Inizializzazione per copia 1 #ifndef __MAXIMUM_H 2 #define __MAXIMUM_H 3 class Maximum 4 {// File: Maximum.h 5 public: 6 Maximum (void); 7 Maximum (int theMaximum); 8 Maximum (Maximum &theMaximum_Ref); 9 ~Maximum (void); 10 Maximum& operator=(Maximum &theMaximum_Ref); }; 12 #endif // __MAXIMUM_H Questo è il metodo che inizializza la copia del dato di tipo Maximum che viene passata in argomento alla funzione Chiamato.

146 Introduzione al linguaggio C++ Inizializzazione per copia 1 #ifndef __MAXIMUM_H 2 #define __MAXIMUM_H 3 class Maximum 4 {// File: Maximum.h 5 public: 6 Maximum (void); 7 Maximum (int theMaximum); 8 Maximum (Maximum &theMaximum_Ref); 9 ~Maximum (void); 10 Maximum& operator=(Maximum &theMaximum_Ref); }; 12 #endif // __MAXIMUM_H Solamente un metodo del tipo di dato Maximum può costruire una copia sicura di un dato del suo tipo.

147 Introduzione al linguaggio C++ Rilascio risorse impegnate

148 Introduzione al linguaggio C++ Rilascio risorse impegnate Il metodo di rilascio delle risorse permette di liberare le aree occupate dal tipo di dato e di rilasciare le risorse impegnate dai metodi di inizializzazione. Inizializzazione minima Inizializzazioni migliori Dato_del_programmatore Inizializzazione per copia Rilascio risorse impegnate Assegnazione Copia (ad uso privato) Rilascio (ad uso privato) 4

149 Introduzione al linguaggio C++ Rilascio risorse impegnate 1 #include Chiamato.h 2 #include Maximum.h 3 #include Limit.h 4 #include Index.h 5 void Chiamante (void) 6 { 7 Maximum Req_Max(10); // Qty foreseen requests 8 Limit Req_Lim; // Qty requests in use 9 Index Req_Ind; // Index to curr. request 10 Chiamato (Req_Max, Req_Lim, Req_Ind); 11 } Quando viene raggiunta la chiusa graffa } il dato Req_Max di tipo Maximum esce dal suo ambito di visibilità e viene automaticamente distrutto dal compilatore.

150 Introduzione al linguaggio C++ Rilascio risorse impegnate 1 #include Chiamato.h 2 #include Maximum.h 3 #include Limit.h 4 #include Index.h 5 void Chiamante (void) 6 { 7 Maximum Req_Max(10); // Qty foreseen requests 8 Limit Req_Lim; // Qty requests in use 9 Index Req_Ind; // Index to curr. request 10 Chiamato (Req_Max, Req_Lim, Req_Ind); 11 } Prima di rilasciare le aree occupate dal tipo di dato definito dal programmatore, il compilatore richiama il metodo di rilascio delle risorse dello specifico tipo di dato.

151 Introduzione al linguaggio C++ Rilascio risorse impegnate 1 #ifndef __MAXIMUM_H 2 #define __MAXIMUM_H 3 class Maximum 4 {// File: Maximum.h 5 public: 6 Maximum (void); 7 Maximum (int theMaximum); 8 Maximum (Maximum &theMaximum_Ref); 9 ~Maximum (void); 10 Maximum& operator=(Maximum &theMaximum_Ref); }; 12 #endif // __MAXIMUM_H Questo è il metodo che rilascia le risorse impegnate dai metodi di inizializzazione dei dati di tipo Maximum.

152 Introduzione al linguaggio C++ Rilascio risorse impegnate 1 #ifndef __MAXIMUM_H 2 #define __MAXIMUM_H 3 class Maximum 4 {// File: Maximum.h 5 public: 6 Maximum (void); 7 Maximum (int theMaximum); 8 Maximum (Maximum &theMaximum_Ref); 9 ~Maximum (void); 10 Maximum& operator=(Maximum &theMaximum_Ref); }; 12 #endif // __MAXIMUM_H Solamente un metodo del tipo di dato Maximum può rilasciare correttamente le risorse impegnate dai suoi metodi di inizializzazione.

153 Introduzione al linguaggio C++ Rilascio risorse impegnate 1 #ifndef __MAXIMUM_H 2 #define __MAXIMUM_H 3 class Maximum 4 {// File: Maximum.h 5 public: 6 Maximum (void); 7 Maximum (int theMaximum); 8 Maximum (Maximum &theMaximum_Ref); 9 ~Maximum (void); 10 Maximum& operator=(Maximum &theMaximum_Ref); }; 12 #endif // __MAXIMUM_H Per ogni tipo di dato definito dal programmatore il metodo di rilascio è unico.

154 Introduzione al linguaggio C++ Rilascio risorse impegnate 1 #ifndef __MAXIMUM_H 2 #define __MAXIMUM_H 3 class Maximum 4 {// File: Maximum.h 5 public: 6 Maximum (void); 7 Maximum (int theMaximum); 8 Maximum (Maximum &theMaximum_Ref); 9 ~Maximum (void); 10 Maximum& operator=(Maximum &theMaximum_Ref); }; 12 #endif // __MAXIMUM_H Ogni metodo di inizializzazione deve annotare quali risorse ha impegnato perché lunico metodo di rilascio le possa correttamente rilasciare.

155 Introduzione al linguaggio C++ Rilascio risorse impegnate 1 #include Chiamato.h 2 #include Maximum.h 3 #include Limit.h 4 #include Index.h 5 void Chiamante (void) 6 { 7 Maximum Req_Max(10); // Qty foreseen requests 8 Limit Req_Lim; // Qty requests in use 9 Index Req_Ind; // Index to curr. request 10 Chiamato (Req_Max, Req_Lim, Req_Ind); 11 } Dopo avere richiamato il metodo di rilascio delle risorse dello specifico tipo di dato, il compilatore rilasciare le aree occupate dal tipo di dato definito dal programmatore.

156 Introduzione al linguaggio C++ Assegnazione

157 Introduzione al linguaggio C++ Assegnazione Il metodo di assegnazione permette di assegnare un dato del tipo definito dal programmatore ad un altro dato dello stesso tipo. Inizializzazione minima Inizializzazioni migliori Dato_del_programmatore Inizializzazione per copia Rilascio risorse impegnate Assegnazione Copia (ad uso privato) Rilascio (ad uso privato) 5

158 Introduzione al linguaggio C++ Assegnazione 1 #include Maximum.h 2 void Calcolo (void) 3 { 4 Maximum Req_Max(10); // Qty foreseen requests 5 Maximum Temp_Max; // Temporary area 6 Temp_Max = Req_Max; } Il programmatore dichiara un dato Req_Max di tipo Maximum e lo inizializza con il valore 10.

159 Introduzione al linguaggio C++ Assegnazione 1 #include Maximum.h 2 void Calcolo (void) 3 { 4 Maximum Req_Max(10); // Qty foreseen requests 5 Maximum Temp_Max; // Temporary area 6 Temp_Max = Req_Max; } Il programmatore dichiara un dato temporaneo Temp_Max di tipo Maximum e lo inizializza al minimo.

160 Introduzione al linguaggio C++ Assegnazione 1 #include Maximum.h 2 void Calcolo (void) 3 { 4 Maximum Req_Max(10); // Qty foreseen requests 5 Maximum Temp_Max; // Temporary area 6 Temp_Max = Req_Max; } Il valore di Req_Max è assegnato a Temp_Max, dato dello stesso tipo (definito dal programmatore).

161 Introduzione al linguaggio C++ Assegnazione 1 #include Maximum.h 2 void Calcolo (void) 3 { 4 Maximum Req_Max(10); // Qty foreseen requests 5 Maximum Temp_Max; // Temporary area 6 Temp_Max = Req_Max; } Quando viene raggiunta la chiusa graffa } i dati Req_Max e Temp_Max di tipo Maximum escono dal loro ambito di visibilità e vengono automaticamente distrutti dal compilatore.

162 Introduzione al linguaggio C++ Assegnazione 1 #include Maximum.h 2 void Calcolo (void) 3 { 4 Maximum Req_Max(10); // Qty foreseen requests 5 Maximum Temp_Max; // Temporary area 6 Temp_Max = Req_Max; } Se lassegnazione specifica del tipo di dato Maximum non è corretta lapplicazione può terminare anormalmente.

163 Introduzione al linguaggio C++ Assegnazione Se i metodi di inizializzazione riservano dinamicamente aree esterne al dato e poi vi accedono mediante puntatori è necessario duplicare le aree esterne nel metodo di assegnazione specifico del tipo di dato definito dal programmatore... operator= Req_Max ~Maximum Value_Ptr Value operator= Temp_Max ~Maximum Value_Ptr Value

164 Introduzione al linguaggio C++ Assegnazione... per evitare di creare involontariamente due puntamenti ad una stessa area esterna. operator= Req_Max ~Maximum Value_Ptr Value operator= Temp_Max ~Maximum Value_Ptr

165 Introduzione al linguaggio C++ Assegnazione Dopo il richiamo al metodo di rilascio delle risorse di Temp_Max le aree esterne di Temp_Max sono state rilasciate... operator= Req_Max ~Maximum Value_Ptr operator= Temp_Max ~Maximum Value_Ptr

166 Introduzione al linguaggio C++ Assegnazione... e se erano condivise con Req_Max, ora Req_Max può trovarsi con un puntatore ad unarea esterna non più valida. operator= Req_Max ~Maximum Value_Ptr operator= Temp_Max ~Maximum Value_Ptr

167 Introduzione al linguaggio C++ Assegnazione Il tentativo di rilasciare le aree di Req_Max può causare la fine anomala dellapplicazione. operator= Req_Max ~Maximum Value_Ptr operator= Temp_Max ~Maximum Value_Ptr

168 Introduzione al linguaggio C++ Assegnazione 1 #ifndef __MAXIMUM_H 2 #define __MAXIMUM_H 3 class Maximum 4 {// File: Maximum.h 5 public: 6 Maximum (void); 7 Maximum (int theMaximum); 8 Maximum (Maximum &theMaximum_Ref); 9 ~Maximum (void); 10 Maximum& operator=(Maximum &theMaximum_Ref); }; 12 #endif // __MAXIMUM_H Questo è il metodo che assegna un dato di tipo Maximum ad un altro dato dello stesso tipo.

169 Introduzione al linguaggio C++ Assegnazione Origine = Destinazione Rilascio risorse della destinazione Copia risorse dellorigine sulla destinazione Fine Sì No Il metodo di assegnazione dei tipi di dati definiti dal programmatore è generalmente composto da tre passi.

170 Introduzione al linguaggio C++ Assegnazione Origine = Destinazione Rilascio risorse della destinazione Copia risorse dellorigine sulla destinazione Sì No Fine Primo passo: Verifica che il dato non si auto-distrugga assegnandosi a se stesso.

171 Introduzione al linguaggio C++ Assegnazione Origine = Destinazione Rilascio risorse della destinazione Copia risorse dellorigine sulla destinazione Sì No Fine Secondo passo: Rilascio delle risorse riservate dinamicamente dai metodi di inizializzazione della destinazione.

172 Introduzione al linguaggio C++ Assegnazione Origine = Destinazione Rilascio risorse della destinazione Copia risorse dellorigine sulla destinazione Sì No Fine Terzo passo: Creazione di una copia delle risorse riservate dinamicamente dai metodi di inizializzazione dellorigine e loro attribuzione alla destinazione.

173 Introduzione al linguaggio C++ Assegnazione Riepilogo: In questa discussione abbiamo visto che: 1.Quando il programmatore definisce un suo tipo di dato deve spiegare al compilatore cosa significa assegnare un dato del nuovo tipo ad un dato dello stesso tipo. 2.Il metodo operator= spiega al compilatore come assegnare un dato di tipo definito dal programmatore ad un altro dato dello stesso tipo. 4.Il metodo di assegnazione dei tipi di dati definiti dal programmatore è generalmente composto da tre passi: verifica di non auto-distruzione; rilascio (ad uso privato) delle risorse della destinazione; copia (ad uso privato) delle risorse dellorigine. 5.Quando i metodi di inizializzazione NON richiedono dinamicamente risorse esterne, il metodo di assegnazione descritto in questa discussione è facoltativo, ma per maggior chiarezza si consiglia di costruirne comunque una versione anche se vuota. 3.Per ogni tipo di dato definito dal programmatore cè un metodo operator= specifico per quel tipo di dato.

174 Introduzione al linguaggio C++ Autodistruzione

175 Introduzione al linguaggio C++ Autodistruzione 1 #include Maximum.h 2 void Calcolo (void) 3 { 4 Maximum Req_Max(10); // Qty foreseen requests 5 Maximum Temp_Max; // Temporary area 6 Req_Max = Req_Max; } Problema: Cosa succede se per errore assegnamo Req_Max a se stesso?

176 Introduzione al linguaggio C++ Autodistruzione Assegnazione Origine = Destinazione Rilascio risorse della destinazione Copia risorse dellorigine sulla destinazione Sì No Fine Primo passo: Verifica che il dato non si auto-distrugga assegnandosi a se stesso. Cosa succederebbe se il metodo di assegnazione non contenesse il primo passo di verifica?

177 Introduzione al linguaggio C++ Autodistruzione Assegnazione Origine = Destinazione Rilascio risorse della destinazione Copia risorse dellorigine sulla destinazione Sì No Fine Secondo passo: Rilascio delle risorse riservate dinamicamente dai metodi di inizializzazione della destinazione. Senza il primo passo di verifica, il secondo passo rilascia le risorse riservate dinamicamante...

178 Introduzione al linguaggio C++ Autodistruzione Assegnazione Origine = Destinazione Rilascio risorse della destinazione Copia risorse dellorigine sulla destinazione Sì No Fine Terzo passo: Creazione di una copia delle risorse riservate dinamicamente dai metodi di inizializzazione dellorigine e loro attribuzione alla destinazione.... ed il terzo passo cerca di copiare risorse che sono appena state rilasciate. Risultato...

179 Introduzione al linguaggio C++ Autodistruzione Assegnazione Origine = Destinazione Rilascio risorse della destinazione Copia risorse dellorigine sulla destinazione Sì No Fine Terzo passo: Creazione di una copia delle risorse riservate dinamicamente dai metodi di inizializzazione dellorigine e loro attribuzione alla destinazione.

180 Introduzione al linguaggio C++ Copia (ad uso privato)

181 Introduzione al linguaggio C++ Copia (ad uso privato) Un metodo di copia (ad uso interno) viene richiamato dal metodo di inizializzazione per copia e dal metodo di assegnazione. Inizializzazione minima Inizializzazioni migliori Dato_del_programmatore Inizializzazione per copia Rilascio risorse impegnate Assegnazione Copia (ad uso privato) Rilascio (ad uso privato) 6

182 Introduzione al linguaggio C++ Copia (ad uso privato) Assegnazione Origine = Destinazione Rilascio risorse della destinazione Copia risorse dellorigine sulla destinazione Sì No Fine Terzo passo: Creazione di una copia delle risorse riservate dinamicamente dai metodi di inizializzazione dellorigine e loro attribuzione alla destinazione. È il terzo passo del metodo di assegnazione.

183 Introduzione al linguaggio C++ Rilascio (ad uso privato)

184 Introduzione al linguaggio C++ Rilascio (ad uso privato) Un metodo di copia (ad uso interno) viene richiamato dal metodo di inizializzazione per copia e dal metodo di assegnazione. Inizializzazione minima Inizializzazioni migliori Dato_del_programmatore Inizializzazione per copia Rilascio risorse impegnate Assegnazione Copia (ad uso privato) Rilascio (ad uso privato) 7

185 Introduzione al linguaggio C++ Rilascio (ad uso privato) È il secondo passo del metodo di assegnazione. Assegnazione Origine = Destinazione Rilascio risorse della destinazione Copia risorse dellorigine sulla destinazione Sì No Fine Secondo passo: Rilascio delle risorse riservate dinamicamente dai metodi di inizializzazione della destinazione.

186 Introduzione al linguaggio C++ Componenti di un dato del programmatore Riepilogo: In questa discussione abbiamo visto che: 1.Ci sono alcuni componenti di servizio che compaiono frequentemente nei tipi di dati definito dal programmatore. 2.Il programmatore deve definire alcune operazioni sul tipo di dato da lui/lei definito per permettere al compilatore di gestire correttamente: il passaggio di argomenti a funzioni; la restituzione di valori da funzioni; il rilascio delle risorse riservate dinamicamente dai metodi di inizializzazione di dati creati automaticamente che escono dal loro ambito di visibilità. 3.Quando i metodi di inizializzazione richiedono dinamicamente risorse esterne i metodi di servizio descritti in questa discussione sono obbligatori. 4.Quando i metodi di inizializzazione NON richiedono dinamicamente risorse esterne, i metodi di servizio descritti in questa discussione sono facoltativi, ma per maggior chiarezza si consiglia di costruirne comunque una versione anche se vuota.

187 Introduzione al linguaggio C++ Costruzione di tipi di dati del programmatore 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. Mario G. Montobbio 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.


Scaricare ppt "Introduzione al linguaggio C++ Costruzione di tipi di dati del programmatore."

Presentazioni simili


Annunci Google