Costruzione di tipi di dati del programmatore
Costruzione di tipi di dati del
programmatore
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.
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:[email protected]
Introduzione al linguaggio C++
Costruzione di tipi di dati del programmatore
Linguaggi senza verifica
del tipo degli argomenti
Introduzione al linguaggio C++
Costruzione di tipi di dati del programmatore
CHIAMANTE
CHIAMATO1
CHIAMATO2
CHIAMATO3
Il linguaggio COBOL non verifica che il tipo degli argomenti passati da un
modulo CHIAMANTE ad una funzione esterna CHIAMATOx sia quello atteso.
Introduzione al linguaggio C++
Costruzione di tipi di dati del programmatore
CHIAMANTE
CHIAMATO1
CHIAMATO2
CHIAMATO3
In assenza di questo controllo automatico il richiamo ad una funzione
esterna CHIAMATOx assomiglia ad una “spina” generica.
Introduzione al linguaggio C++
Costruzione di tipi di dati del programmatore
CHIAMANTE
CHIAMATO1
CHIAMATO2
CHIAMATO3
La “spina” del modulo CHIAMANTE può collegarsi con la “presa” della
funzione CHIAMATO1.
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 CHIAMATO1
corrispondono esattamente.
Introduzione al linguaggio C++
Costruzione di tipi di dati del programmatore
CHIAMANTE
CHIAMATO1
CHIAMATO2
Questa è la situazione ideale.
Introduzione al linguaggio C++
CHIAMATO3
Costruzione di tipi di dati del programmatore
CHIAMANTE
CHIAMATO1
CHIAMATO2
CHIAMATO3
La “spina” del modulo CHIAMANTE può collegarsi anche con la “presa” della
funzione CHIAMATO2.
Introduzione al linguaggio C++
Costruzione di tipi di dati del programmatore
CHIAMANTE
CHIAMATO2
CHIAMATO1
CHIAMATO3
La “spina” del modulo CHIAMANTE e la “presa” della funzione CHIAMATO2
non corrispondono esattamente, ma – con qualche avvertenza – possono
permettere il funzionamento.
Introduzione al linguaggio C++
Costruzione di tipi di dati del programmatore
CHIAMANTE
CHIAMATO2
CHIAMATO1
CHIAMATO3
Questo metodo di richiamo funziona se utilizzo solamente i primi tre “denti”
ricevuti da CHIAMANTE ...
Introduzione al linguaggio C++
Costruzione di tipi di dati del programmatore
CHIAMANTE
CHIAMATO2
CHIAMATO1
CHIAMATO3
... ma può causare una fine anomala dell’elaborazione se il programmatore
di CHIAMATO2 utilizza il quarto “dente” che non ha mai ricevuto da
CHIAMANTE.
Introduzione al linguaggio C++
Costruzione di tipi di dati del programmatore
CHIAMANTE
CHIAMATO1
CHIAMATO2
CHIAMATO3
La “spina” del modulo CHIAMANTE può collegarsi anche con la “presa”
della funzione CHIAMATO3.
Introduzione al linguaggio C++
Costruzione di tipi di dati del programmatore
CHIAMANTE
CHIAMATO3
CHIAMATO1
CHIAMATO2
La “spina” del modulo CHIAMANTE e la “presa” della funzione CHIAMATO2
non corrispondono esattamente, ma – con qualche avvertenza – possono
permettere il funzionamento.
Introduzione al linguaggio C++
Costruzione di tipi di dati del programmatore
CHIAMANTE
CHIAMATO3
CHIAMATO1
CHIAMATO2
Questo metodo di richiamo funziona se utilizzo solamente il formato del
secondo “dente” ricevuto da CHIAMANTE ...
Introduzione al linguaggio C++
Costruzione di tipi di dati del programmatore
CHIAMANTE
CHIAMATO3
CHIAMATO1
CHIAMATO2
... ma può causare risultati imprevedibili oppure una fine anomala
dell’elaborazione se il programmatore di CHIAMATO3 utilizza la punta del
secondo “dente” che non ha mai ricevuto da CHIAMANTE.
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 l’elaborazione dove la quantità e il tipo degli argomenti
sono uguali nel CHIAMANTE e nel CHIAMATO1 è sicura.
4. Talvolta i programmatori COBOL sfruttano l’assenza di verifiche sugli
argomenti.
5. Solamente in casi molto particolari (es.: moduli generalizzati, quantità
di argomenti variabili) è giustificato lo sfruttamento dell’assenza di
verifiche sugli argomenti.
Introduzione al linguaggio C++
Costruzione di tipi di dati del programmatore
Linguaggi con verifica
del tipo degli argomenti
Introduzione al linguaggio C++
Costruzione di tipi di dati del programmatore
Chiamante
Chiamato1
Chiamato2
Chiamato3
Il linguaggio C++ verifica che il tipo degli argomenti passati da un modulo
Chiamante ad una funzione esterna Chiamatox sia quello atteso.
Introduzione al linguaggio C++
Costruzione di tipi di dati del programmatore
Chiamante
Chiamato1
Chiamato2
Chiamato3
In presenza di questo controllo automatico il richiamo ad una funzione
esterna CHIAMATOx assomiglia ad una “spina” specializzata.
Introduzione al linguaggio C++
Costruzione di tipi di dati del programmatore
Chiamante
Chiamato1
Chiamato2
Chiamato3
La “spina” del modulo Chiamante può collegarsi con la “presa” della
funzione Chiamato1.
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 Chiamato1
corrispondono esattamente.
Introduzione al linguaggio C++
Costruzione di tipi di dati del programmatore
Chiamante
Chiamato1
Chiamato2
Questa è la situazione ideale.
Introduzione al linguaggio C++
Chiamato3
Costruzione di tipi di dati del programmatore
Chiamante
Chiamato1
Chiamato2
Chiamato3
La “spina” del modulo Chiamante NON può collegarsi anche con la
“presa” della funzione Chiamato2 ...
Introduzione al linguaggio C++
Costruzione di tipi di dati del programmatore
Chiamante
Chiamato1
Chiamato2
Chiamato3
... infatti il modulo Chiamante NON passa il quarto argomento atteso dalla
funzione Chiamato2.
Introduzione al linguaggio C++
Costruzione di tipi di dati del programmatore
Chiamante
Chiamante
Chiamato1
Chiamato2
Chiamato3
Il richiamo dal modulo Chiamante alla funzione esterna Chiamato2 non è
un richiamo sicuro
Introduzione al linguaggio C++
Costruzione di tipi di dati del programmatore
Chiamante
Chiamato1
Chiamato2
Chiamato3
La “spina” del modulo Chiamante NON può collegarsi anche con la
“presa” della funzione Chiamato3 ...
Introduzione al linguaggio C++
Costruzione di tipi di dati del programmatore
Chiamante
Chiamato1
Chiamato2
Chiamato3
... infatti il secondo argomento passato dal modulo Chiamante NON è
dello stesso tipo del secondo argomento atteso dalla funzione Chiamato3.
Introduzione al linguaggio C++
Costruzione di tipi di dati del programmatore
Chiamante
Chiamante
Chiamato1
Chiamato2
Chiamato3
Il richiamo dal modulo Chiamante alla funzione esterna Chiamato3 non è
un richiamo sicuro
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 l’elaborazione 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).
Introduzione al linguaggio C++
Mancanza di modello delle funzioni esterne
Mancanza di modello delle funzioni
esterne
Introduzione al linguaggio C++
Mancanza di modello delle funzioni esterne
1
2
...
3
4
5
6
7
8
9
10
IDENTIFICATION DIVISION.
PROGRAM-ID. CHIAMANTE.
...
WORKING-STORAGE SECTION.
01 REQ-AREA.
10 REQ-MAX
PIC S9(9) VALUE +10
COMP.
* Quantity of foreseen iteration requests.
10 REQ-LIM
PIC S9(9) VALUE ZERO COMP.
* Quantity of iteration requests in use.
10 REQ-IND
PIC S9(9) VALUE ZERO COMP.
* Index to the current iteration request.
Questo è un esempio di dichiarazione di aree nel modulo CHIAMANTE
scritto in linguaggio COBOL.
Introduzione al linguaggio C++
Mancanza di modello delle funzioni esterne
1
2
...
3
4
5
6
7
8
9
10
IDENTIFICATION DIVISION.
PROGRAM-ID. CHIAMANTE.
...
WORKING-STORAGE SECTION.
01 REQ-AREA.
10 REQ-MAX
PIC S9(9) VALUE +10
COMP.
* Quantity of foreseen iteration requests.
10 REQ-LIM
PIC S9(9) VALUE ZERO COMP.
* Quantity of iteration requests in use.
10 REQ-IND
PIC S9(9) VALUE ZERO COMP.
* Index to the current iteration request.
Queste clausole specificano i tipi di dati delle aree ...
Introduzione al linguaggio C++
Mancanza di modello delle funzioni esterne
1
2
...
3
4
5
6
7
8
9
10
IDENTIFICATION DIVISION.
PROGRAM-ID. CHIAMANTE.
...
WORKING-STORAGE SECTION.
01 REQ-AREA.
10 REQ-MAX
PIC S9(9) VALUE +10
COMP.
* Quantity of foreseen iteration requests.
10 REQ-LIM
PIC S9(9) VALUE ZERO COMP.
* Quantity of iteration requests in use.
10 REQ-IND
PIC S9(9) VALUE ZERO COMP.
* Index to the current iteration request.
... che hanno questi nomi (definiti dal programmatore).
Introduzione al linguaggio C++
Mancanza di modello delle funzioni esterne
1
2
...
3
4
5
...
IDENTIFICATION DIVISION.
PROGRAM-ID. CHIAMANTE.
...
CALL “CHIAMATO” USING REQ-MAX,
REQ-LIM,
REQ-IND.
...
Se passiamo le tre aree definite nel modulo CHIAMANTE come argomenti
ad una funzione esterna CHIAMATO ...
Introduzione al linguaggio C++
Mancanza di modello delle funzioni esterne
1
2
...
3
4
5
6
7
8
9
...
IDENTIFICATION DIVISION.
PROGRAM-ID. CHIAMATO.
...
LINKAGE SECTION.
01 ZZ-REQ-MAX
PIC S9(9) COMP.
01 ZZ-REQ-LIM
PIC S9(9) COMP.
01 ZZ-REQ-IND
PIC S9(9) COMP.
PROCEDURE DIVISION USING ZZ-REQ-MAX, 1
ZZ-REQ-LIM, 2
ZZ-REQ-IND. 3
...
... è il programmatore che deve manualmente verificare che in CHIAMATO
l’ordine di definizione degli argomenti ricevuti ...
Introduzione al linguaggio C++
Mancanza di modello delle funzioni esterne
1
2
...
3
4
5
...
IDENTIFICATION DIVISION.
PROGRAM-ID. CHIAMANTE.
...
CALL “CHIAMATO” USING REQ-MAX, 1
REQ-LIM, 2
REQ-IND. 3
...
... corrisponda a quello della chiamata a funzione esterna nel modulo
CHIAMANTE.
Introduzione al linguaggio C++
Mancanza di modello delle funzioni esterne
1
2
...
3
4
5
6
7
8
9
...
IDENTIFICATION DIVISION.
PROGRAM-ID. CHIAMATO.
...
LINKAGE SECTION.
01 ZZ-REQ-MAX
PIC S9(9) COMP.
01 ZZ-REQ-LIM
PIC S9(9) COMP.
01 ZZ-REQ-IND
PIC S9(9) COMP.
PROCEDURE DIVISION USING ZZ-REQ-MAX,
ZZ-REQ-LIM,
ZZ-REQ-IND.
...
È il programmatore che deve manualmente verificare che in CHIAMATO i
tipi degli argomenti ...
Introduzione al linguaggio C++
Mancanza di modello delle funzioni esterne
1
2
...
3
4
5
6
7
8
9
10
IDENTIFICATION DIVISION.
PROGRAM-ID. CHIAMANTE.
...
WORKING-STORAGE SECTION.
01 REQ-AREA.
10 REQ-MAX
PIC S9(9) VALUE +10
COMP.
* Quantity of foreseen iteration requests.
10 REQ-LIM
PIC S9(9) VALUE ZERO COMP.
* Quantity of iteration requests in use.
10 REQ-IND
PIC S9(9) VALUE ZERO COMP.
* Index to the current iteration request.
... corrispondano a quelli passati dal modulo CHIAMANTE.
Introduzione al linguaggio C++
Mancanza di modello delle funzioni esterne
1
2
...
3
4
5
6
7
8
9
...
IDENTIFICATION DIVISION.
PROGRAM-ID. CHIAMATO.
...
LINKAGE SECTION.
01 ZZ-REQ-MAX
PIC S9(9) COMP.
01 ZZ-REQ-LIM
PIC S9(9) COMP.
01 ZZ-REQ-IND
PIC S9(9) COMP.
PROCEDURE DIVISION USING ZZ-REQ-MAX,
ZZ-REQ-LIM,
ZZ-REQ-IND.
...
Problema: La quantità e l’ordine degli argomenti della funzione esterna
CHIAMATO ed il loro tipo NON sono sintetizzati in un modello di funzione ...
Introduzione al linguaggio C++
Mancanza di modello delle funzioni esterne
1
2
...
3
4
5
6
IDENTIFICATION DIVISION.
PROGRAM-ID. CHIAMANTE.
...
CALL “CHIAMATO” USING REQ-MAX, 1
REQ-LIM, 2
REQ-IND. 3
...
... che sia disponibile durante la compilazione del modulo CHIAMANTE e
che permetta al compilatore di verificare automaticamente che la quantità e
l’ordine degli argomenti passati da CHIAMANTE a CHIAMATO ...
Introduzione al linguaggio C++
Mancanza di modello delle funzioni esterne
1
2
...
3
4
5
6
7
8
9
10
IDENTIFICATION DIVISION.
PROGRAM-ID. CHIAMANTE.
...
WORKING-STORAGE SECTION.
01 REQ-AREA.
10 REQ-MAX
PIC S9(9) VALUE +10
COMP.
* Quantity of foreseen iteration requests.
10 REQ-LIM
PIC S9(9) VALUE ZERO COMP.
* Quantity of iteration requests in use.
10 REQ-IND
PIC S9(9) VALUE ZERO COMP.
* Index to the current iteration request.
... ed i loro tipi corrispondano.
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.
Introduzione al linguaggio C++
Inconvenienti della mancanza di modello
Inconvenienti della mancanza di modello
Introduzione al linguaggio C++
Omissione di un argomento
Errore Nr. 1
Omissione di un argomento
Introduzione al linguaggio C++
Omissione di un argomento
1
2
...
3
4
...
IDENTIFICATION DIVISION.
PROGRAM-ID. CHIAMANTE.
...
CALL “CHIAMATO” USING REQ-LIM,
REQ-IND.
...
Se per errore il programmatore omette REQ-MAX nel richiamo a CHIAMATO
...
Introduzione al linguaggio C++
Omissione di un argomento
1
2
...
3
4
5
6
7
8
9
...
IDENTIFICATION DIVISION.
PROGRAM-ID. CHIAMATO.
...
LINKAGE SECTION.
01 ZZ-REQ-MAX
PIC S9(9) COMP.
01 ZZ-REQ-LIM
PIC S9(9) COMP.
01 ZZ-REQ-IND
PIC S9(9) COMP.
PROCEDURE DIVISION USING ZZ-REQ-MAX,
ZZ-REQ-LIM,
ZZ-REQ-IND.
...
... sarebbe comodo che il compilatore confrontasse il richiamo (in
CHIAMANTE) con il modello di CHIAMATO e ci avvertisse dell’omissione
dell’argomento.
Introduzione al linguaggio C++
Omissione di un argomento
1
2
...
3
4
...
IDENTIFICATION DIVISION.
PROGRAM-ID. CHIAMANTE.
...
CALL “CHIAMATO” USING REQ-LIM,
REQ-IND.
...
Problema: Il compilatore non può segnalarci l’errore poiché CHIAMANTE
non conosce il modello di CHIAMATO.
Introduzione al linguaggio C++
Omissione di un argomento
Riepilogo: In questa discussione abbiamo visto che:
1. Il linguaggio COBOL non identifica durante la compilazione
l’omissione 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.
Introduzione al linguaggio C++
Inversione di due argomenti
Errore Nr. 2
Inversione di due argomenti
Introduzione al linguaggio C++
Inversione di due argomenti
1
2
...
3
4
5
...
IDENTIFICATION DIVISION.
PROGRAM-ID. CHIAMANTE.
...
CALL “CHIAMATO” USING REQ-LIM,
REQ-MAX,
REQ-IND.
...
Se per errore il programmatore inverte REQ-MAX e REQ-LIM nel richiamo a
CHIAMATO ...
Introduzione al linguaggio C++
Inversione di due argomenti
1
2
...
3
4
5
...
IDENTIFICATION DIVISION.
PROGRAM-ID. CHIAMANTE.
...
CALL “CHIAMATO” USING REQ-LIM,
REQ-MAX,
REQ-IND.
...
... il compilatore non può segnalarci l’errore poiché CHIAMANTE non
conosce il modello di CHIAMATO.
Introduzione al linguaggio C++
Inversione di due argomenti
1
2
...
3
4
5
6
7
8
9
...
IDENTIFICATION DIVISION.
PROGRAM-ID. CHIAMATO.
...
LINKAGE SECTION.
01 ZZ-REQ-MAX
PIC S9(9) COMP.
01 ZZ-REQ-LIM
PIC S9(9) COMP.
01 ZZ-REQ-IND
PIC S9(9) COMP.
PROCEDURE DIVISION USING ZZ-REQ-MAX,
ZZ-REQ-LIM,
ZZ-REQ-IND.
...
In questo caso – anche se confrontassimo il richiamo col modello di
CHIAMATO – l’inversione degli argomenti è ancora più difficile da rilevare
poiché sono entrambi dello stesso tipo: PIC S9(9) COMP.
Introduzione al linguaggio C++
Inversione di due argomenti
1
2
...
3
4
5
6
7
8
9
10
IDENTIFICATION DIVISION.
PROGRAM-ID. CHIAMANTE.
...
WORKING-STORAGE SECTION.
01 REQ-AREA.
10 REQ-MAX
PIC S9(9) VALUE +10
COMP.
* Quantity of foreseen iteration requests.
10 REQ-LIM
PIC S9(9) VALUE ZERO COMP.
* Quantity of iteration requests in use.
10 REQ-IND
PIC S9(9) VALUE ZERO COMP.
* Index to the current iteration request.
Esaminando i nomi delle aree, notiamo che le aree rappresentano concetti
diversi ...
Introduzione al linguaggio C++
Inversione di due argomenti
1
2
...
3
4
5
6
7
8
9
10
IDENTIFICATION DIVISION.
PROGRAM-ID. CHIAMANTE.
...
WORKING-STORAGE SECTION.
01 REQ-AREA.
10 REQ-MAX
PIC S9(9) VALUE +10
COMP.
* Quantity of foreseen iteration requests.
10 REQ-LIM
PIC S9(9) VALUE ZERO COMP.
* Quantity of iteration requests in use.
10 REQ-IND
PIC S9(9) VALUE ZERO COMP.
* Index to the current iteration request.
REQ-MAX è un valore massimo ...
Introduzione al linguaggio C++
Inversione di due argomenti
1
2
...
3
4
5
6
7
8
9
10
IDENTIFICATION DIVISION.
PROGRAM-ID. CHIAMANTE.
...
WORKING-STORAGE SECTION.
01 REQ-AREA.
10 REQ-MAX
PIC S9(9) VALUE +10
COMP.
* Quantity of foreseen iteration requests.
10 REQ-LIM
PIC S9(9) VALUE ZERO COMP.
* Quantity of iteration requests in use.
10 REQ-IND
PIC S9(9) VALUE ZERO COMP.
* Index to the current iteration request.
... mentre REQ-LIM è un valore in uso.
Introduzione al linguaggio C++
Inversione di due argomenti
1
2
...
3
4
5
6
7
8
9
...
IDENTIFICATION DIVISION.
PROGRAM-ID. CHIAMATO.
...
LINKAGE SECTION.
01 ZZ-REQ-MAX
PIC S9(9) COMP.
01 ZZ-REQ-LIM
PIC S9(9) COMP.
01 ZZ-REQ-IND
PIC S9(9) COMP.
PROCEDURE DIVISION USING ZZ-REQ-MAX,
ZZ-REQ-LIM,
ZZ-REQ-IND.
...
Sarebbe utile che il compilatore ci permettesse di distinguere fra un valore
massimo e un valore in uso ...
Introduzione al linguaggio C++
Inversione di due argomenti
1
2
...
3
4
5
6
7
8
9
...
IDENTIFICATION DIVISION.
PROGRAM-ID. CHIAMATO.
...
LINKAGE SECTION.
01 ZZ-REQ-MAX
PIC S9(9) COMP.
01 ZZ-REQ-LIM
PIC S9(9) COMP.
01 ZZ-REQ-IND
PIC S9(9) COMP.
PROCEDURE DIVISION USING ZZ-REQ-MAX,
ZZ-REQ-LIM,
ZZ-REQ-IND.
...
... e confrontasse il richiamo (in CHIAMANTE) con il modello di CHIAMATO e
ci avvertisse dell’inversione degli argomenti.
Introduzione al linguaggio C++
Inversione di due argomenti
1
2
...
3
4
5
6
7
8
9
...
IDENTIFICATION DIVISION.
PROGRAM-ID. CHIAMATO.
...
LINKAGE SECTION.
01 ZZ-REQ-MAX
PIC S9(9) COMP.
01 ZZ-REQ-LIM
PIC S9(9) COMP.
01 ZZ-REQ-IND
PIC S9(9) COMP.
PROCEDURE DIVISION USING ZZ-REQ-MAX,
ZZ-REQ-LIM,
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.
Introduzione al linguaggio C++
Inversione di due argomenti
1
2
...
3
4
5
6
7
8
9
10
IDENTIFICATION DIVISION.
PROGRAM-ID. CHIAMANTE.
...
WORKING-STORAGE SECTION.
01 REQ-AREA.
10 REQ-MAX
PIC S9(9) VALUE +10
COMP.
* Quantity of foreseen iteration requests.
10 REQ-LIM
PIC S9(9) VALUE ZERO COMP.
* Quantity of iteration requests in use.
10 REQ-IND
PIC S9(9) VALUE ZERO COMP.
* 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.
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
l’inversione 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.
3. Il programmatore deve controllare manualmente che i tipi degli
argomenti nel modulo CHIAMANTE e nel modulo CHIAMATO1 siano
uguali.
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 l’inversione di due argomenti
che hanno lo stesso tipo – PIC S9(9) COMP – pre-definito nel
linguaggio.
Introduzione al linguaggio C++
Scambio di aggregato in argomento
Errore Nr. 3
Scambio di aggregato in argomento
Introduzione al linguaggio C++
Scambio di aggregato in argomento
1
2
...
3
4
5
6
7
8
9
10
IDENTIFICATION DIVISION.
PROGRAM-ID. CHIAMANTE.
...
WORKING-STORAGE SECTION.
01 REQ-AREA.
10 REQ-MAX
PIC S9(9) VALUE +10
COMP.
* Quantity of foreseen iteration requests.
10 REQ-LIM
PIC S9(9) VALUE ZERO COMP.
* Quantity of iteration requests in use.
10 REQ-IND
PIC S9(9) VALUE ZERO COMP.
* 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.
Introduzione al linguaggio C++
Scambio di aggregato in argomento
1
2
...
3
...
IDENTIFICATION DIVISION.
PROGRAM-ID. CHIAMANTE.
...
CALL “CHIAMATO” USING REQ-AREA.
...
Possiamo richiamare una versione modificata di CHIAMATO passando
come argomento un aggregato REQ-AREA ...
Introduzione al linguaggio C++
Scambio di aggregato in argomento
1
2
...
3
...
IDENTIFICATION DIVISION.
PROGRAM-ID. CHIAMANTE.
...
CALL “CHIAMATO” USING OTHER-AREA.
...
Ma se – per errore – nel richiamo a CHIAMATO il programmatore passa
l’aggregato OTHER-AREA al posto di REQ-AREA ...
Introduzione al linguaggio C++
Scambio di aggregato in argomento
1
2
...
3
...
IDENTIFICATION DIVISION.
PROGRAM-ID. CHIAMANTE.
...
CALL “CHIAMATO” USING OTHER-AREA.
...
... il compilatore non ci può avvertire ...
Introduzione al linguaggio C++
Scambio di aggregato in argomento
1
2
...
3
...
11
12
13
14
15
IDENTIFICATION DIVISION.
PROGRAM-ID. CHIAMANTE.
...
WORKING-STORAGE SECTION.
...
01 OTHER-AREA.
10 OTHER-NAME PIC X(9)
VALUE “FERRUCCIO”.
10 OTHER-ROLE PIC X(8)
VALUE “THE BEST”.
... poiché – a parte l’assenza di modello – anche OTHER-AREA è un
aggregato di aree come REQ-AREA.
Introduzione al linguaggio C++
Scambio di aggregato in argomento
3
4
5
6
7
8
9
10
11
12
...
WORKING-STORAGE SECTION.
01 REQ-AREA.
10 REQ-MAX
PIC S9(9) VALUE +10
COMP.
* Quantity of foreseen iteration requests.
10 REQ-LIM
PIC S9(9) VALUE ZERO COMP.
* Quantity of iteration requests in use.
10 REQ-IND
PIC S9(9) VALUE ZERO COMP.
* Index to the current iteration request.
01 OTHER-AREA.
10 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.
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 dell’argomento 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 l’inversione di due argomenti
che siano entrambi aggregati.
Introduzione al linguaggio C++
Presenza di modello delle funzioni
Presenza di modello delle funzioni
Introduzione al linguaggio C++
Presenza di modello delle funzioni
1
2
3
4
5
6
7
8
9
10
11
#include “Chiamato.h”
#include “Maximum.h”
#include “Limit.h”
#include “Index.h”
void Chiamante (void)
{
Maximum Req_Max(10); // Qty foreseen requests
Limit
Req_Lim;
// Qty requests in use
Index
Req_Ind;
// Index to curr. request
Chiamato (Req_Max, Req_Lim, Req_Ind);
}
Questo è un esempio di dichiarazione di aree e di richiamo alla funzione
Chiamato nella funzione Chiamante scritta in linguaggio C++.
Introduzione al linguaggio C++
Presenza di modello delle funzioni
1
2
3
4
5
6
7
8
9
10
11
#include “Chiamato.h”
#include “Maximum.h”
#include “Limit.h”
#include “Index.h”
void Chiamante (void)
{
Maximum Req_Max(10); // Qty foreseen requests
Limit
Req_Lim;
// Qty requests in use
Index
Req_Ind;
// Index to curr. request
Chiamato (Req_Max, Req_Lim, Req_Ind);
}
Queste clausole specificano i tipi di dati delle aree ...
Introduzione al linguaggio C++
Presenza di modello delle funzioni
1
2
3
4
5
6
7
8
9
10
11
#include “Chiamato.h”
#include “Maximum.h”
#include “Limit.h”
#include “Index.h”
void Chiamante (void)
{
Maximum Req_Max(10); // Qty foreseen requests
Limit
Req_Lim;
// Qty requests in use
Index
Req_Ind;
// Index to curr. request
Chiamato (Req_Max, Req_Lim, Req_Ind);
}
... che hanno questi nomi (definiti dal programmatore).
Introduzione al linguaggio C++
Presenza di modello delle funzioni
1
2
3
4
5
6
7
8
9
10
11
#include “Chiamato.h”
#include “Maximum.h”
#include “Limit.h”
#include “Index.h”
void Chiamante (void)
{
Maximum Req_Max(10); // Qty foreseen requests
Limit
Req_Lim;
// Qty requests in use
Index
Req_Ind;
// Index to curr. request
Chiamato (Req_Max, Req_Lim, Req_Ind);
}
Se passiamo le tre aree definite nella funzione Chiamante come
argomenti ad una funzione Chiamato ...
Introduzione al linguaggio C++
Presenza di modello delle funzioni
1
2
3
4
5
6
7
8
9
10
11
#include “Chiamato.h”
#include “Maximum.h”
#include “Limit.h”
#include “Index.h”
void Chiamante (void)
{
Maximum Req_Max(10); // Qty foreseen requests
Limit
Req_Lim;
// Qty requests in use
Index
Req_Ind;
// Index to curr. request
Chiamato (Req_Max, Req_Lim, Req_Ind);
}
1
2
3
... il compilatore può automaticamente verificare che l’ordine di definizione
degli argomenti ricevuti nel richiamo alla funzione Chiamato ...
Introduzione al linguaggio C++
Presenza di modello delle funzioni
1
2
3
4
5
6
7
8
9
10
11
#include “Chiamato.h”
#include “Maximum.h”
#include “Limit.h”
#include “Index.h”
void Chiamante (void)
{
Maximum Req_Max(10); // Qty foreseen requests
Limit
Req_Lim;
// Qty requests in use
Index
Req_Ind;
// Index to curr. request
Chiamato (Req_Max, Req_Lim, Req_Ind);
}
1
2
3
... sia uguale a quello definito nel modello delle funzione Chiamato ...
Introduzione al linguaggio C++
Presenza di modello delle funzioni
1
2
3
4
5
6
7
#ifndef __CHIAMATO_H
// File: Chiamato.h
#define __CHIAMATO_H
void Chiamato (Maximum theMaximum 1
,Limit
theLimit
2
,Index
theIndex); 3
#endif // __CHIAMATO_H
... che è contenuto nell’intestazione Chiamato.h
Introduzione al linguaggio C++
Presenza di modello delle funzioni
1
2
3
4
5
6
7
8
9
10
11
#include “Chiamato.h”
#include “Maximum.h”
#include “Limit.h”
#include “Index.h”
void Chiamante (void)
{
Maximum Req_Max(10); // Qty foreseen requests
Limit
Req_Lim;
// Qty requests in use
Index
Req_Ind;
// Index to curr. request
Chiamato (Req_Max, Req_Lim, Req_Ind);
}
Il compilatore ricerca il tipo del primo argomento Req_Max ...
Introduzione al linguaggio C++
Presenza di modello delle funzioni
1
2
3
4
5
6
7
8
9
10
11
#include “Chiamato.h”
#include “Maximum.h“
#include “Limit.h”
#include “Index.h”
void Chiamante (void)
{
2
3 Maximum Req_Max(10); // Qty foreseen requests
Limit
Req_Lim;
// Qty requests in use
Index
Req_Ind;
// Index to curr. request
Chiamato (Req_Max, Req_Lim, Req_Ind);
}
1
... che è dichiarato nel corpo della funzione Chiamante ...
Introduzione al linguaggio C++
Presenza di modello delle funzioni
1
2
3
4
5
6
7
8
9
10
11
#include “Chiamato.h”
#include “Maximum.h“ 4
#include “Limit.h”
#include “Index.h”
void Chiamante (void)
{
2
3 Maximum Req_Max(10); // Qty foreseen requests
Limit
Req_Lim;
// Qty requests in use
Index
Req_Ind;
// Index to curr. request
Chiamato (Req_Max, Req_Lim, Req_Ind);
}
1
... ed è definito nell’intestazione Maximum.h.
Introduzione al linguaggio C++
Presenza di modello delle funzioni
1
2
3
4
5
6
7
8
9
10
...
11
12
#ifndef __MAXIMUM_H
#define __MAXIMUM_H
class Maximum
{// File: Maximum.h
public:
Maximum (void);
Maximum (int theMaximum);
Maximum (Maximum &theMaximum_Ref);
~Maximum (void);
Maximum& operator=(Maximum &theMaximum_Ref);
...
};
#endif // __MAXIMUM_H
Nell’intestazione Maximum.h con la parola riservata
programmatore definisce un nuovo tipo di dato Maximum ...
Introduzione al linguaggio C++
class
il
Presenza di modello delle funzioni
1
2
3
4
5
6
7
8
9
10
11
#include “Chiamato.h”
#include “Maximum.h”
#include “Limit.h”
#include “Index.h”
void Chiamante (void)
{
Maximum Req_Max(10); // Qty foreseen requests
Limit
Req_Lim;
// Qty requests in use
Index
Req_Ind;
// Index to curr. request
Chiamato (Req_Max, Req_Lim, Req_Ind);
}
... che può essere usato per dichiarare un’area di tipo Maximum nel corpo
della funzione Chiamante ...
Introduzione al linguaggio C++
Presenza di modello delle funzioni
1
2
3
4
5
6
7
#ifndef __CHIAMATO_H
// File: Chiamato.h
#define __CHIAMATO_H
void Chiamato (Maximum theMaximum
,Limit
theLimit
,Index
theIndex);
#endif // __CHIAMATO_H
... e può essere usato nell’intestazione Chiamato.h per definire il tipo del
primo argomento theMaximum della funzione Chiamato.
Introduzione al linguaggio C++
Presenza di modello delle funzioni
1
2
3
4
5
6
7
...
8
9
10
11
...
#ifndef __CHIAMATO_H
// File: Chiamato.h
#define __CHIAMATO_H
void Chiamato (Maximum theMaximum
,Limit
theLimit
,Index
theIndex);
#endif // __CHIAMATO_H
...
Maximum Req_Max(10); // Qty foreseen requests
Limit
Req_Lim;
// Qty requests in use
Index
Req_Ind;
// Index to curr. request
Chiamato (Req_Max, Req_Lim, Req_Ind);
...
Nel modello della funzione Chiamato ...
Introduzione al linguaggio C++
Presenza di modello delle funzioni
1
2
3
4
5
6
7
...
8
9
10
11
...
#ifndef __CHIAMATO_H
// File: Chiamato.h
#define __CHIAMATO_H
void Chiamato (Maximum theMaximum 1
,Limit
theLimit
,Index
theIndex);
#endif // __CHIAMATO_H
...
Maximum Req_Max(10); // Qty foreseen requests
Limit
Req_Lim;
// Qty requests in use
Index
Req_Ind;
// Index to curr. request
Chiamato (Req_Max, Req_Lim, Req_Ind);
...
... il primo argomento fittizio theMaximum ...
Introduzione al linguaggio C++
Presenza di modello delle funzioni
1
2
3
4
5
6
7
...
8
9
10
11
...
#ifndef __CHIAMATO_H
// File: Chiamato.h
#define __CHIAMATO_H
void Chiamato2 (Maximum theMaximum 1
,Limit
theLimit
,Index
theIndex);
#endif // __CHIAMATO_H
...
Maximum Req_Max(10); // Qty foreseen requests
Limit
Req_Lim;
// Qty requests in use
Index
Req_Ind;
// Index to curr. request
Chiamato (Req_Max, Req_Lim, Req_Ind);
...
... è di tipo Maximum ...
Introduzione al linguaggio C++
Presenza di modello delle funzioni
1
2
3
4
5
6
7
...
8
9
10
11
...
#ifndef __CHIAMATO_H
// File: Chiamato.h
#define __CHIAMATO_H
void Chiamato2 (Maximum theMaximum 1
,Limit
theLimit
,Index
theIndex);
#endif // __CHIAMATO_H
...
Maximum Req_Max(10); // Qty foreseen requests
Limit
Req_Lim;
// Qty requests in use
Index
Req_Ind;
// Index to curr. request
Chiamato (Req_Max, Req_Lim, Req_Ind);
3
...
... e corrisponde all’argomento reale Req_Max ...
Introduzione al linguaggio C++
Presenza di modello delle funzioni
1
2
3
4
5
6
7
...
8
9
10
11
...
#ifndef __CHIAMATO_H
// File: Chiamato.h
#define __CHIAMATO_H
void Chiamato2 (Maximum theMaximum 1
,Limit
theLimit
,Index
theIndex);
#endif // __CHIAMATO_H
...
4
Maximum Req_Max(10); // Qty foreseen requests
Limit
Req_Lim;
// Qty requests in use
Index
Req_Ind;
// Index to curr. request
Chiamato (Req_Max, Req_Lim, Req_Ind);
3
...
... che è dichiarato nel corpo della funzione Chiamante ...
Introduzione al linguaggio C++
Presenza di modello delle funzioni
1
2
3
4
5
6
7
...
8
9
10
11
...
#ifndef __CHIAMATO_H
// File: Chiamato.h
#define __CHIAMATO_H
void Chiamato2 (Maximum theMaximum 1
,Limit
theLimit
,Index
theIndex);
#endif // __CHIAMATO_H
...
4
5 Maximum Req_Max(10); // Qty foreseen requests
Limit
Req_Lim;
// Qty requests in use
Index
Req_Ind;
// Index to curr. request
Chiamato (Req_Max, Req_Lim, Req_Ind);
3
...
... di tipo Maximum.
Introduzione al linguaggio C++
Presenza di modello delle funzioni
1
2
3
4
5
6
7
...
8
9
10
11
...
#ifndef __CHIAMATO_H
// File: Chiamato.h
#define __CHIAMATO_H
void Chiamato1 (Maximum theMaximum
,Limit
theLimit
,Index
theIndex);
#endif // __CHIAMATO_H
...
2 Maximum Req_Max(10); // Qty foreseen requests
Limit
Req_Lim;
// Qty requests in use
Index
Req_Ind;
// Index to curr. request
Chiamato (Req_Max, Req_Lim, Req_Ind);
...
Poiché l’argomento reale Req_Max e quello formale theMaximum
appartengono allo stesso tipo di dato Maximum ...
Introduzione al linguaggio C++
Presenza di modello delle funzioni
1
2
3
4
5
6
7
...
8
9
10
11
...
#ifndef __CHIAMATO_H
// File: Chiamato.h
#define __CHIAMATO_H
void Chiamato (Maximum theMaximum 3
,Limit
theLimit
,Index
theIndex);
#endif // __CHIAMATO_H
...
Maximum 1 Req_Max(10); // Qty foreseen requests
Limit
Req_Lim;
// Qty requests in use
Index
Req_Ind;
// Index to curr. request
Chiamato2 (Req_Max, Req_Lim, Req_Ind);
...
... è possibile passare Req_Max come primo argomento alla funzione
Chiamato.
Introduzione al linguaggio C++
Presenza di modello delle funzioni
1
2
3
4
5
6
7
...
8
9
10
11
...
#ifndef __CHIAMATO_H
// File: Chiamato.h
#define __CHIAMATO_H
void Chiamato (Maximum theMaximum
,Limit
theLimit
,Index
theIndex);
#endif // __CHIAMATO_H
...
Maximum Req_Max(10); // Qty foreseen requests
Limit
Req_Lim;
// Qty requests in use
Index
Req_Ind;
// Index to curr. request
Chiamato (Req_Max, Req_Lim, Req_Ind);
...
Analogamente il secondo argomento reale Req_Lim passato alla funzione
Chiamato ...
Introduzione al linguaggio C++
Presenza di modello delle funzioni
1
2
3
4
5
6
7
...
8
9
10
11
...
#ifndef __CHIAMATO_H
// File: Chiamato.h
#define __CHIAMATO_H
void Chiamato (Maximum theMaximum
,Limit
theLimit
,Index
theIndex);
#endif // __CHIAMATO_H
...
Maximum Req_Max(10); // Qty foreseen requests
Limit
Req_Lim; 2
// Qty requests in use
Index
Req_Ind;
// Index to curr. request
Chiamato (Req_Max, Req_Lim, Req_Ind);
1
...
... è dichiarato nel corpo della funzione Chiamante ...
Introduzione al linguaggio C++
Presenza di modello delle funzioni
1
2
3
4
5
6
7
...
8
9
10
11
...
#ifndef __CHIAMATO_H
// File: Chiamato.h
#define __CHIAMATO_H
void Chiamato (Maximum theMaximum
,Limit
theLimit
,Index
theIndex);
#endif // __CHIAMATO_H
...
Maximum Req_Max(10); // Qty foreseen requests
Req_Lim; 2
// Qty requests in use
3 Limit
Index
Req_Ind;
// Index to curr. request
Chiamato (Req_Max, Req_Lim, Req_Ind);
1
...
... ed è di tipo Limit.
Introduzione al linguaggio C++
Presenza di modello delle funzioni
1
2
3
4
5
6
7
...
8
9
10
11
...
#ifndef __CHIAMATO_H
// File: Chiamato.h
#define __CHIAMATO_H
void Chiamato (Maximum theMaximum
theLimit
4 ,Limit
,Index
theIndex);
#endif // __CHIAMATO_H
...
Maximum Req_Max(10); // Qty foreseen requests
Req_Lim; 2
// Qty requests in use
3 Limit
Index
Req_Ind;
// Index to curr. request
Chiamato (Req_Max, Req_Lim, Req_Ind);
1
...
... proprio come il secondo argomento formale theLimit nel modello della
funzione Chiamato.
Introduzione al linguaggio C++
Presenza di modello delle funzioni
1
2
3
4
5
6
7
8
9
10
11
#include “Chiamato.h”
#include “Maximum.h”
#include “Limit.h”
#include “Index.h”
void Chiamante (void)
{
Maximum Req_Max(10); // Qty foreseen requests
Limit
Req_Lim;
// Qty requests in use
Index
Req_Ind;
// Index to curr. request
Chiamato (Req_Max, Req_Lim, Req_Ind);
}
Il tipo di dato del programmatore Limit è definito nell’intestazione
Limit.h ...
Introduzione al linguaggio C++
Presenza di modello delle funzioni
1
2
3
4
5
6
7
8
9
10
...
11
12
#ifndef __LIMIT_H
#define __LIMIT_H
class Limit
{// File: Limit.h
public:
Limit (void);
Limit (int theLimit);
Limit (Limit &theLimit_Ref);
~Limit (void);
Limit& operator=(Limit &theLimit_Ref);
...
};
#endif // __LIMIT_H
... con la parola riservata class seguita dal nome del nuovo tipo di dato
Limit.
Introduzione al linguaggio C++
Presenza di modello delle funzioni
1
2
3
4
5
6
7
...
8
9
10
11
...
#ifndef __CHIAMATO_H
// File: Chiamato.h
#define __CHIAMATO_H
void Chiamato (Maximum theMaximum
theLimit
1 ,Limit
,Index
theIndex);
#endif // __CHIAMATO_H
...
Maximum Req_Max(10); // Qty foreseen requests
Req_Lim;
// Qty requests in use
2 Limit
Index
Req_Ind;
// Index to curr. request
Chiamato (Req_Max, Req_Lim, Req_Ind);
...
Poiché l’argomento reale Req_Lim e quello
appartengono allo stesso tipo di dato Limit ...
Introduzione al linguaggio C++
formale
theLimit
Presenza di modello delle funzioni
1
2
3
4
5
6
7
...
8
9
10
11
...
#ifndef __CHIAMATO_H
// File: Chiamato.h
#define __CHIAMATO_H
void Chiamato (Maximum theMaximum
,Limit
theLimit 3
,Index
theIndex);
#endif // __CHIAMATO_H
...
Maximum Req_Max(10); // Qty foreseen requests
Limit 1 Req_Lim;
// Qty requests in use
2
Index
Req_Ind;
// Index to curr. request
Chiamato (Req_Max, Req_Lim, Req_Ind);
...
... è possibile passare Req_Lim come secondo argomento alla funzione
Chiamato.
Introduzione al linguaggio C++
Presenza di modello delle funzioni
1
2
3
4
5
6
7
...
8
9
10
11
...
#ifndef __CHIAMATO_H
// File: Chiamato.h
#define __CHIAMATO_H
void Chiamato (Maximum theMaximum
,Limit
theLimit
,Index
theIndex);
#endif // __CHIAMATO_H
...
Maximum Req_Max(10); // Qty foreseen requests
Limit
Req_Lim;
// Qty requests in use
Index
Req_Ind;
// Index to curr. request
Chiamato (Req_Max, Req_Lim, Req_Ind);
...
Analogamente il terzo argomento reale Req_Ind passato alla funzione
Chiamato ...
Introduzione al linguaggio C++
Presenza di modello delle funzioni
1
2
3
4
5
6
7
...
8
9
10
11
...
#ifndef __CHIAMATO_H
// File: Chiamato.h
#define __CHIAMATO_H
void Chiamato (Maximum theMaximum
,Limit
theLimit
,Index
theIndex);
#endif // __CHIAMATO_H
...
Maximum Req_Max(10); // Qty foreseen requests
Limit
Req_Lim;
// Qty requests in use
Index
Req_Ind; 2
// Index to curr. request
Chiamato (Req_Max, Req_Lim, Req_Ind);
1
...
... è dichiarato nel corpo della funzione Chiamante ...
Introduzione al linguaggio C++
Presenza di modello delle funzioni
1
2
3
4
5
6
7
...
8
9
10
11
...
#ifndef __CHIAMATO_H
// File: Chiamato.h
#define __CHIAMATO_H
void Chiamato (Maximum theMaximum
,Limit
theLimit
,Index
theIndex);
#endif // __CHIAMATO_H
...
Maximum Req_Max(10); // Qty foreseen requests
Limit
Req_Lim;
// Qty requests in use
Req_Ind; 2
// Index to curr. request
3 Index
Chiamato (Req_Max, Req_Lim, Req_Ind);
1
...
... ed è di tipo Index.
Introduzione al linguaggio C++
Presenza di modello delle funzioni
1
2
3
4
5
6
7
...
8
9
10
11
...
#ifndef __CHIAMATO_H
// File: Chiamato.h
#define __CHIAMATO_H
void Chiamato (Maximum theMaximum
,Limit
theLimit
theIndex);
4 ,Index
#endif // __CHIAMATO_H
...
Maximum Req_Max(10); // Qty foreseen requests
Limit
Req_Lim;
// Qty requests in use
Req_Ind; 2
// Index to curr. request
3 Index
Chiamato (Req_Max, Req_Lim, Req_Ind);
1
...
... proprio come il terzo argomento formale theIndex nel modello della
funzione Chiamato.
Introduzione al linguaggio C++
Presenza di modello delle funzioni
1
2
3
4
5
6
7
8
9
10
11
#include “Chiamato.h”
#include “Maximum.h”
#include “Limit.h”
#include “Index.h”
void Chiamante (void)
{
Maximum Req_Max(10); // Qty foreseen requests
Limit
Req_Lim;
// Qty requests in use
Index
Req_Ind;
// Index to curr. request
Chiamato (Req_Max, Req_Lim, Req_Ind);
}
Il tipo di dato del programmatore Index è definito nell’intestazione
Index.h ...
Introduzione al linguaggio C++
Presenza di modello delle funzioni
1
2
3
4
5
6
7
8
9
10
...
11
12
#ifndef __INDEX_H
#define __INDEX_H
class Index
{// File: Index.h
public:
Index (void);
Index (int theIndex);
Index (Limit &theIndex_Ref);
~Index (void);
Index& operator=(Index &theIndex_Ref);
...
};
#endif // __INDEX_H
... con la parola riservata class seguita dal nome del nuovo tipo di dato
Index.
Introduzione al linguaggio C++
Presenza di modello delle funzioni
1
2
3
4
5
6
7
...
8
9
10
11
...
#ifndef __CHIAMATO_H
// File: Chiamato.h
#define __CHIAMATO_H
void Chiamato (Maximum theMaximum
,Limit
theLimit
theIndex);
1 ,Index
#endif // __CHIAMATO_H
...
Maximum Req_Max(10); // Qty foreseen requests
Limit
Req_Lim;
// Qty requests in use
Req_Ind;
// Index to curr. request
2 Index
Chiamato (Req_Max, Req_Lim, Req_Ind);
...
Poiché l’argomento reale Req_Ind e quello
appartengono allo stesso tipo di dato Index ...
Introduzione al linguaggio C++
formale
theIndex
Presenza di modello delle funzioni
1
2
3
4
5
6
7
...
8
9
10
11
...
#ifndef __CHIAMATO_H
// File: Chiamato.h
#define __CHIAMATO_H
void Chiamato (Maximum theMaximum
,Limit
theLimit
,Index
theIndex); 3
#endif // __CHIAMATO_H
...
Maximum Req_Max(10); // Qty foreseen requests
Limit
Req_Lim;
// Qty requests in use
Index 1 Req_Ind;
// Index to curr. request
Chiamato (Req_Max, Req_Lim, Req_Ind); 2
...
... è possibile passare Req_Ind come terzo argomento alla funzione
Chiamato.
Introduzione al linguaggio C++
Presenza di modello delle funzioni
1
2
3
4
5
6
7
8
9
10
...
11
12
Chiamante
#ifndef __MAXIMUM_H
#define __MAXIMUM_H
class Maximum
{// File: Maximum.h
Chiamato
public:
Maximum (void);
Maximum (int theMaximum);
Maximum (Maximum &theMaximum_Ref);
~Maximum (void);
Maximum& operator=(Maximum &theMaximum_Ref);
...
};
#endif // __MAXIMUM_H
Nell’intestazione Maximum.h con la parola riservata
programmatore definisce la forma del primo “dente”.
Introduzione al linguaggio C++
class
il
Presenza di modello delle funzioni
1
2
3
4
5
6
7
8
9
10
...
11
12
Chiamante
#ifndef __LIMIT_H
#define __LIMIT_H
class Limit
{// File: Limit.h
Chiamato
public:
Limit (void);
Limit (int theLimit);
Limit (Limit &theLimit_Ref);
~Limit (void);
Limit& operator=(Limit &theLimit_Ref);
...
};
#endif // __LIMIT_H
Nell’intestazione Limit.h con la parola riservata class il programmatore
definisce la forma del secondo “dente”.
Introduzione al linguaggio C++
Presenza di modello delle funzioni
1
2
3
4
5
6
7
8
9
10
...
11
12
Chiamante
#ifndef __INDEX_H
#define __INDEX_H
class Index
{// File: Index.h
Chiamato
public:
Index (void);
Index (int theIndex);
Index (Limit &theIndex_Ref);
~Index (void);
Index& operator=(Index &theIndex_Ref);
...
};
#endif // __INDEX_H
Nell’intestazione Index.h con la parola riservata class il programmatore
definisce la forma del terzo “dente”.
Introduzione al linguaggio C++
Presenza di modello delle funzioni
1
2
3
4
5
6
7
8
9
10
11
Chiamante
#include “Chiamato.h”
1
2
3
#include “Maximum.h”
#include “Limit.h”
#include “Index.h”
Chiamato
void Chiamante (void)
{
Maximum Req_Max(10); // Qty foreseen requests
Limit
Req_Lim;
// Qty requests in use
Index
Req_Ind;
// Index to curr. request
Chiamato (Req_Max, Req_Lim, Req_Ind);
}
1
2
3
L’ordine dei tre argomenti nel richiamo a Chiamato definisce l’ordine dei
“denti” nella “spina” Chiamante.
Introduzione al linguaggio C++
Presenza di modello delle funzioni
Chiamante
1
2
3
4
5
6
7
#ifndef __CHIAMATO_H
// File: Chiamato.h
#define __CHIAMATO_H
void Chiamato (Maximum theMaximum 4
,Limit
theLimit
5
,Index
theIndex);
6
#endif // __CHIAMATO_H
4
5
6
Chiamato
L’ordine dei tre argomenti nel modello della funzione Chiamato definisce
l’ordine dei “denti” nella “presa” Chiamato.
Introduzione al linguaggio C++
Presenza di modello delle funzioni
Chiamante
1
...
4
5
6
...
8
9
10
11
...
...
void
Chiamato4 (Maximum theMaximum
theLimit
5 ,Limit
theIndex);
6 ,Index
...
1 Maximum
2 Limit
3 Index
Chiamato
...
2
3
4
5
6
Chiamato
Req_Max(10); // Qty foreseen requests
Req_Lim;
// Qty requests in use
Req_Ind;
// Index to curr. request
(Req_Max, Req_Lim, Req_Ind);
Le forme della “spina” Chiamante
corrispondono esattamente.
Introduzione al linguaggio C++
e
della
“presa”
Chiamato
Omissione di un argomento
Errore Nr. 1
Omissione di un argomento
Introduzione al linguaggio C++
Omissione di un argomento
1
2
3
4
5
6
7
8
9
10
11
#include “Chiamato.h”
#include “Maximum.h”
#include “Limit.h”
#include “Index.h”
void Chiamante (void)
{
Maximum Req_Max(10); // Qty foreseen requests
Limit
Req_Lim;
// Qty requests in use
Index
Req_Ind;
// Index to curr. request
Chiamato (Req_Lim, Req_Ind);
}
1
2
Il compilatore può automaticamente verificare che la quantità degli
argomenti ricevuti nel richiamo alla funzione Chiamato ...
Introduzione al linguaggio C++
Omissione di un argomento
1
2
3
4
5
6
7
#ifndef __CHIAMATO_H
// File: Chiamato.h
#define __CHIAMATO_H
void Chiamato (Maximum theMaximum 1
,Limit
theLimit
2
,Index
theIndex); 3
#endif // __CHIAMATO_H
... non corrisponde nell’intestazione Chiamato.h alla quantità di argomenti
definiti nel modello della funzione Chiamato.
Introduzione al linguaggio C++
Inversione di due argomenti
Errore Nr. 2
Inversione di due argomenti
Introduzione al linguaggio C++
Inversione di due argomenti
1
2
3
4
5
6
7
8
9
10
11
#include “Chiamato.h”
#include “Maximum.h”
#include “Limit.h”
#include “Index.h”
void Chiamante (void)
{
Maximum Req_Max(10); // Qty foreseen requests
Limit
Req_Lim;
// Qty requests in use
Index
Req_Ind;
// Index to curr. request
Chiamato (Req_Lim, Req_Max, Req_Ind);
}
B
A
C
Se per errore il programmatore inverte Req_Max e Req_Lim nel richiamo a
Chiamato ...
Introduzione al linguaggio C++
Inversione di due argomenti
1
2
3
4
5
6
7
#ifndef __CHIAMATO_H
// File: Chiamato.h
#define __CHIAMATO_H
void Chiamato (Maximum theMaximum A
,Limit
theLimit
B
,Index
theIndex); C
#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 nell’intestazione Chiamato.h ai tipi degli argomenti definiti
nel modello della funzione Chiamato.
Introduzione al linguaggio C++
Scambio di aggregato in argomento
Errore Nr. 3
Scambio di aggregato in argomento
Introduzione al linguaggio C++
Scambio di aggregato in argomento
1
2
3
4
5
6
7
8
9
10
11
#include “Chiamato.h”
#include “Maximum.h”
#include “Limit.h”
#include “Index.h”
void Chiamante (void)
{
Maximum Req_Max(10); // Qty foreseen requests
Limit
Req_Lim;
// Qty requests in use
Index
Req_Ind;
// Index to curr. request
Chiamato (Req_Lim, Req_Max, Req_Ind);
}
B
A
C
Poiché il compilatore C++ distingue fra i tipi degli aggregati l’errore Nr. 3
viene riconosciuto esattamente come l’errore Nr. 2.
Introduzione al linguaggio C++
Scambio di aggregato in argomento
1
2
3
4
5
6
7
#ifndef __CHIAMATO_H
// File: Chiamato.h
#define __CHIAMATO_H
void Chiamato (Maximum theMaximum A
,Limit
theLimit
B
,Index
theIndex); C
#endif // __CHIAMATO_H
Il compilatore può automaticamente verificare se i tipi degli argomenti
ricevuti
nel richiamo alla funzione Chiamato corrispondono
nell’intestazione Chiamato.h ai tipi degli argomenti definiti nel modello
della funzione Chiamato.
Introduzione al linguaggio C++
Componenti di un dato del programmatore
Componenti di un dato del
programmatore
Introduzione al linguaggio C++
Componenti di un dato del programmatore
Dato_del_programmatore
1
Inizializzazione “minima”
2
Inizializzazioni “migliori”
3
Inizializzazione per copia
4
Rilascio risorse impegnate
5
Assegnazione
6
Copia (ad uso privato)
7
Rilascio (ad uso privato)
Ci sono alcuni componenti di servizio che compaiono frequentemente nei
tipi di dati definito dal programmatore.
Introduzione al linguaggio C++
Componenti di un dato del programmatore
Dato_del_programmatore
1
Inizializzazione “minima”
Inizializzazioni “migliori”
Inizializzazione per copia
Rilascio risorse impegnate
Assegnazione
Copia (ad uso privato)
Rilascio (ad uso privato)
Il metodo di inizializzazione “minima” ci permette di costruire un dato valido
del tipo definito dal programmatore senza conoscere alcun valore.
Introduzione al linguaggio C++
Componenti di un dato del programmatore
Dato_del_programmatore
Inizializzazione “minima”
2
Inizializzazioni “migliori”
Inizializzazione per copia
Rilascio risorse impegnate
Assegnazione
Copia (ad uso privato)
Rilascio (ad uso privato)
I metodi di inizializzazione “migliori” ci permettono di costruire un dato del
tipo definito dal programmatore partendo da valori in argomento.
Introduzione al linguaggio C++
Componenti di un dato del programmatore
Dato_del_programmatore
Inizializzazione “minima”
Inizializzazioni “migliori”
3
Inizializzazione per copia
Rilascio risorse impegnate
Assegnazione
Copia (ad uso privato)
Rilascio (ad uso privato)
Il metodo di inizializzazione per copia ci permette di passare un dato ad
una funzione e di farcelo restituire da una funzione.
Introduzione al linguaggio C++
Componenti di un dato del programmatore
Dato_del_programmatore
Inizializzazione “minima”
Inizializzazioni “migliori”
Inizializzazione per copia
4
Rilascio risorse impegnate
Assegnazione
Copia (ad uso privato)
Rilascio (ad uso privato)
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.
Introduzione al linguaggio C++
Componenti di un dato del programmatore
Dato_del_programmatore
Inizializzazione “minima”
Inizializzazioni “migliori”
Inizializzazione per copia
Rilascio risorse impegnate
5
Assegnazione
Copia (ad uso privato)
Rilascio (ad uso privato)
Il metodo di assegnazione permette di assegnare un dato del tipo definito
dal programmatore ad un altro dato dello stesso tipo.
Introduzione al linguaggio C++
Componenti di un dato del programmatore
Dato_del_programmatore
Inizializzazione “minima”
Inizializzazioni “migliori”
Inizializzazione per copia
Rilascio risorse impegnate
Assegnazione
6
Copia (ad uso privato)
Rilascio (ad uso privato)
Un metodo di copia (ad uso interno) viene richiamato dal metodo di
inizializzazione per copia e dal metodo di assegnazione.
Introduzione al linguaggio C++
Componenti di un dato del programmatore
Dato_del_programmatore
Inizializzazione “minima”
Inizializzazioni “migliori”
Inizializzazione per copia
Rilascio risorse impegnate
Assegnazione
Copia (ad uso privato)
7
Rilascio (ad uso privato)
Un metodo di rilascio (ad uso interno) viene richiamato dal metodo
(pubblico) di rilascio delle risorse impegnate e dal metodo di assegnazione.
Introduzione al linguaggio C++
Inizializzazione “minima”
Inizializzazione “minima”
Introduzione al linguaggio C++
Inizializzazione “minima”
Dato_del_programmatore
1
Inizializzazione “minima”
Inizializzazioni “migliori”
Inizializzazione per copia
Rilascio risorse impegnate
Assegnazione
Copia (ad uso privato)
Rilascio (ad uso privato)
Il metodo di inizializzazione “minima” ci permette di costruire un dato valido
del tipo definito dal programmatore senza conoscere alcun valore.
Introduzione al linguaggio C++
Inizializzazione “minima”
1
2
3
4
5
6
7
8
9
10
11
#include “Chiamato.h”
#include “Maximum.h”
#include “Limit.h”
#include “Index.h”
void Chiamante (void)
{
Maximum Req_Max(10); // Qty foreseen requests
Limit
Req_Lim;
// Qty requests in use
Index
Req_Ind;
// Index to curr. request
Chiamato (Req_Max, Req_Lim, Req_Ind);
}
Questo è un esempio di dichiarazione “minima” di un dato Req_Lim di tipo
Limit (definito dal programmatore) ...
Introduzione al linguaggio C++
Inizializzazione “minima”
1
2
3
4
5
6
7
8
9
10
...
11
12
#ifndef __LIMIT_H
#define __LIMIT_H
class Limit
{// File: Limit.h
public:
Limit (void);
Limit (int theLimit);
Limit (Limit &theLimit_Ref);
~Limit (void);
Limit& operator=(Limit &theLimit_Ref);
...
};
#endif // __LIMIT_H
... e questo è il metodo che viene richiamato per inizializzare il dato di tipo
Limit.
Introduzione al linguaggio C++
Inizializzazione “minima”
1
2
3
4
5
6
7
8
9
10
...
11
12
#ifndef __LIMIT_H
#define __LIMIT_H
class Limit
{// File: Limit.h
public:
Limit (void);
Limit (int theLimit);
Limit (Limit &theLimit_Ref);
~Limit (void);
Limit& operator=(Limit &theLimit_Ref);
...
};
#endif // __LIMIT_H
Poiché non partiamo da argomenti di nessun tipo non possiamo che
inizializzare il dato con valori “minimi” validi.
Introduzione al linguaggio C++
Inizializzazioni “migliori”
Inizializzazioni “migliori”
Introduzione al linguaggio C++
Inizializzazioni “migliori”
Dato_del_programmatore
Inizializzazione “minima”
2
Inizializzazioni “migliori”
Inizializzazione per copia
Rilascio risorse impegnate
Assegnazione
Copia (ad uso privato)
Rilascio (ad uso privato)
I metodi di inizializzazione “migliori” ci permettono di costruire un dato del
tipo definito dal programmatore partendo da valori in argomento.
Introduzione al linguaggio C++
Inizializzazioni “migliori”
1
2
3
4
5
6
7
8
9
10
11
#include “Chiamato.h”
#include “Maximum.h”
#include “Limit.h”
#include “Index.h”
void Chiamante (void)
{
Maximum Req_Max(10); // Qty foreseen requests
Limit
Req_Lim;
// Qty requests in use
Index
Req_Ind;
// Index to curr. request
Chiamato (Req_Max, Req_Lim, Req_Ind);
}
Questo è un esempio di dichiarazione “migliore” di un dato Req_Max di tipo
Maximum (definito dal programmatore) ...
Introduzione al linguaggio C++
Inizializzazioni “migliori”
1
2
3
4
5
6
7
8
9
10
...
11
12
#ifndef __MAXIMUM_H
#define __MAXIMUM_H
class Maximum
{// File: Maximum.h
public:
Maximum (void);
Maximum (int theMaximum);
Maximum (Limit &theMaximum_Ref);
~Maximum (void);
Maximum& operator=(Maximum &theMaximum_Ref);
...
};
#endif // __MAXIMUM_H
... e questo è il metodo che viene richiamato per inizializzare il dato di tipo
Maximum.
Introduzione al linguaggio C++
Inizializzazione per copia
Inizializzazione per copia
Introduzione al linguaggio C++
Inizializzazione per copia
Dato_del_programmatore
Inizializzazione “minima”
Inizializzazioni “migliori”
3
Inizializzazione per copia
Rilascio risorse impegnate
Assegnazione
Copia (ad uso privato)
Rilascio (ad uso privato)
Il metodo di inizializzazione per copia ci permette di passare un dato ad
una funzione e di farcelo restituire da una funzione.
Introduzione al linguaggio C++
Inizializzazione per copia
1
2
3
4
5
6
7
8
9
10
11
#include “Chiamato.h”
#include “Maximum.h”
#include “Limit.h”
#include “Index.h”
void Chiamante (void)
{
Maximum Req_Max(10); // Qty foreseen requests
Limit
Req_Lim;
// Qty requests in use
Index
Req_Ind;
// Index to curr. request
Chiamato (Req_Max, Req_Lim, Req_Ind);
}
Questo è un esempio di passaggio di un dato Req_Max di tipo Maximum
(definito dal programmatore) in argomento alla funzione Chiamato.
Introduzione al linguaggio C++
Inizializzazione per copia
1
2
3
4
5
6
7
8
9
10
11
#include “Chiamato.h”
#include “Maximum.h”
#include “Limit.h”
#include “Index.h”
void Chiamante (void)
{
Maximum Req_Max(10); // Qty foreseen requests
Limit
Req_Lim;
// Qty requests in use
Index
Req_Ind;
// Index to curr. request
Chiamato (Req_Max, Req_Lim, Req_Ind);
}
Il compilatore richiama automaticamente il metodo di inizializzazione per
copia specifico per il tipo di dato Maximum per creare l’argomento da
passare alla funzione Chiamato.
Introduzione al linguaggio C++
Inizializzazione per copia
1
2
3
4
5
6
7
8
9
10
...
11
12
#ifndef __MAXIMUM_H
#define __MAXIMUM_H
class Maximum
{// File: Maximum.h
public:
Maximum (void);
Maximum (int theMaximum);
Maximum (Maximum &theMaximum_Ref);
~Maximum (void);
Maximum& operator=(Maximum &theMaximum_Ref);
...
};
#endif // __MAXIMUM_H
Questo è il metodo che inizializza la copia del dato di tipo Maximum che
viene passata in argomento alla funzione Chiamato.
Introduzione al linguaggio C++
Inizializzazione per copia
1
2
3
4
5
6
7
8
9
10
...
11
12
#ifndef __MAXIMUM_H
#define __MAXIMUM_H
class Maximum
{// File: Maximum.h
public:
Maximum (void);
Maximum (int theMaximum);
Maximum (Maximum &theMaximum_Ref);
~Maximum (void);
Maximum& operator=(Maximum &theMaximum_Ref);
...
};
#endif // __MAXIMUM_H
Solamente un metodo del tipo di dato Maximum può costruire una copia
“sicura” di un dato del suo tipo.
Introduzione al linguaggio C++
Rilascio risorse impegnate
Rilascio risorse impegnate
Introduzione al linguaggio C++
Rilascio risorse impegnate
Dato_del_programmatore
Inizializzazione “minima”
Inizializzazioni “migliori”
Inizializzazione per copia
4
Rilascio risorse impegnate
Assegnazione
Copia (ad uso privato)
Rilascio (ad uso privato)
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.
Introduzione al linguaggio C++
Rilascio risorse impegnate
1
2
3
4
5
6
7
8
9
10
11
#include “Chiamato.h”
#include “Maximum.h”
#include “Limit.h”
#include “Index.h”
void Chiamante (void)
{
Maximum Req_Max(10); // Qty foreseen requests
Limit
Req_Lim;
// Qty requests in use
Index
Req_Ind;
// Index to curr. request
Chiamato (Req_Max, Req_Lim, Req_Ind);
}
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.
Introduzione al linguaggio C++
Rilascio risorse impegnate
1
2
3
4
5
6
7
8
9
10
11
#include “Chiamato.h”
#include “Maximum.h”
#include “Limit.h”
#include “Index.h”
void Chiamante (void)
{
Maximum Req_Max(10); // Qty foreseen requests
Limit
Req_Lim;
// Qty requests in use
Index
Req_Ind;
// Index to curr. request
Chiamato (Req_Max, Req_Lim, Req_Ind);
}
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.
Introduzione al linguaggio C++
Rilascio risorse impegnate
1
2
3
4
5
6
7
8
9
10
...
11
12
#ifndef __MAXIMUM_H
#define __MAXIMUM_H
class Maximum
{// File: Maximum.h
public:
Maximum (void);
Maximum (int theMaximum);
Maximum (Maximum &theMaximum_Ref);
~Maximum (void);
Maximum& operator=(Maximum &theMaximum_Ref);
...
};
#endif // __MAXIMUM_H
Questo è il metodo che rilascia le risorse impegnate dai metodi di
inizializzazione dei dati di tipo Maximum.
Introduzione al linguaggio C++
Rilascio risorse impegnate
1
2
3
4
5
6
7
8
9
10
...
11
12
#ifndef __MAXIMUM_H
#define __MAXIMUM_H
class Maximum
{// File: Maximum.h
public:
Maximum (void);
Maximum (int theMaximum);
Maximum (Maximum &theMaximum_Ref);
~Maximum (void);
Maximum& operator=(Maximum &theMaximum_Ref);
...
};
#endif // __MAXIMUM_H
Solamente un metodo del tipo di dato Maximum può rilasciare
correttamente le risorse impegnate dai suoi metodi di inizializzazione.
Introduzione al linguaggio C++
Rilascio risorse impegnate
1
2
3
4
5
6
7
8
9
10
...
11
12
#ifndef __MAXIMUM_H
#define __MAXIMUM_H
class Maximum
{// File: Maximum.h
public:
Maximum (void);
Maximum (int theMaximum);
Maximum (Maximum &theMaximum_Ref);
~Maximum (void);
Maximum& operator=(Maximum &theMaximum_Ref);
...
};
#endif // __MAXIMUM_H
Per ogni tipo di dato definito dal programmatore il metodo di rilascio è
unico.
Introduzione al linguaggio C++
Rilascio risorse impegnate
1
2
3
4
5
6
7
8
9
10
...
11
12
#ifndef __MAXIMUM_H
#define __MAXIMUM_H
class Maximum
{// File: Maximum.h
public:
Maximum (void);
Maximum (int theMaximum);
Maximum (Maximum &theMaximum_Ref);
~Maximum (void);
Maximum& operator=(Maximum &theMaximum_Ref);
...
};
#endif // __MAXIMUM_H
Ogni metodo di inizializzazione deve annotare quali risorse ha impegnato
perché l’unico metodo di rilascio le possa correttamente rilasciare.
Introduzione al linguaggio C++
Rilascio risorse impegnate
1
2
3
4
5
6
7
8
9
10
11
#include “Chiamato.h”
#include “Maximum.h”
#include “Limit.h”
#include “Index.h”
void Chiamante (void)
{
Maximum Req_Max(10); // Qty foreseen requests
Limit
Req_Lim;
// Qty requests in use
Index
Req_Ind;
// Index to curr. request
Chiamato (Req_Max, Req_Lim, Req_Ind);
}
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.
Introduzione al linguaggio C++
Assegnazione
Assegnazione
Introduzione al linguaggio C++
Assegnazione
Dato_del_programmatore
Inizializzazione “minima”
Inizializzazioni “migliori”
Inizializzazione per copia
Rilascio risorse impegnate
5
Assegnazione
Copia (ad uso privato)
Rilascio (ad uso privato)
Il metodo di assegnazione permette di assegnare un dato del tipo definito
dal programmatore ad un altro dato dello stesso tipo.
Introduzione al linguaggio C++
Assegnazione
1
2
3
4
5
6
...
7
#include “Maximum.h”
void Calcolo (void)
{
Maximum Req_Max(10); // Qty foreseen requests
Maximum Temp_Max;
// Temporary area
Temp_Max = Req_Max;
...
}
Il programmatore dichiara un dato Req_Max di tipo Maximum e lo
inizializza con il valore 10.
Introduzione al linguaggio C++
Assegnazione
1
2
3
4
5
6
...
7
#include “Maximum.h”
void Calcolo (void)
{
Maximum Req_Max(10); // Qty foreseen requests
Maximum Temp_Max;
// Temporary area
Temp_Max = Req_Max;
...
}
Il programmatore dichiara un dato temporaneo Temp_Max di tipo Maximum
e lo inizializza al “minimo”.
Introduzione al linguaggio C++
Assegnazione
1
2
3
4
5
6
...
7
#include “Maximum.h”
void Calcolo (void)
{
Maximum Req_Max(10); // Qty foreseen requests
Maximum Temp_Max;
// Temporary area
Temp_Max = Req_Max;
...
}
Il “valore” di Req_Max è assegnato a Temp_Max, dato dello stesso tipo
(definito dal programmatore).
Introduzione al linguaggio C++
Assegnazione
1
2
3
4
5
6
...
7
#include “Maximum.h”
void Calcolo (void)
{
Maximum Req_Max(10); // Qty foreseen requests
Maximum Temp_Max;
// Temporary area
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.
Introduzione al linguaggio C++
Assegnazione
1
2
3
4
5
6
...
7
#include “Maximum.h”
void Calcolo (void)
{
Maximum Req_Max(10); // Qty foreseen requests
Maximum Temp_Max;
// Temporary area
Temp_Max = Req_Max;
...
}
Se l’assegnazione specifica del tipo di dato Maximum non è corretta
l’applicazione può terminare anormalmente.
Introduzione al linguaggio C++
Assegnazione
Req_Max
Temp_Max
operator=
operator=
~Maximum
~Maximum
Value_Ptr
Value_Ptr
Value
Value
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 ...
Introduzione al linguaggio C++
Assegnazione
Req_Max
Temp_Max
operator=
operator=
~Maximum
~Maximum
Value_Ptr
Value_Ptr
Value
... per evitare di creare involontariamente due puntamenti ad una stessa
area esterna.
Introduzione al linguaggio C++
Assegnazione
Req_Max
Temp_Max
operator=
operator=
~Maximum
~Maximum
Value_Ptr
Value_Ptr
Dopo il richiamo al metodo di rilascio delle risorse di Temp_Max le aree
esterne di Temp_Max sono state rilasciate ...
Introduzione al linguaggio C++
Assegnazione
Req_Max
Temp_Max
operator=
operator=
~Maximum
~Maximum
Value_Ptr
Value_Ptr
... e se erano condivise con Req_Max, ora Req_Max può trovarsi con un
puntatore ad un’area esterna non più valida.
Introduzione al linguaggio C++
Assegnazione
Req_Max
Temp_Max
operator=
operator=
~Maximum
~Maximum
Value_Ptr
Value_Ptr
Il tentativo di rilasciare le aree di Req_Max può causare la fine anomala
dell’applicazione.
Introduzione al linguaggio C++
Assegnazione
1
2
3
4
5
6
7
8
9
10
...
11
12
#ifndef __MAXIMUM_H
#define __MAXIMUM_H
class Maximum
{// File: Maximum.h
public:
Maximum (void);
Maximum (int theMaximum);
Maximum (Maximum &theMaximum_Ref);
~Maximum (void);
Maximum& operator=(Maximum &theMaximum_Ref);
...
};
#endif // __MAXIMUM_H
Questo è il metodo che assegna un dato di tipo Maximum ad un altro dato
dello stesso tipo.
Introduzione al linguaggio C++
Assegnazione
Il metodo di assegnazione
dei tipi di dati definiti dal
programmatore
è
generalmente composto da
tre passi.
Assegnazione
Origine
=
Destinazione
Sì
No
Rilascio risorse
della destinazione
Copia risorse dell’origine
sulla destinazione
Fine
Introduzione al linguaggio C++
Assegnazione
Assegnazione
Primo passo: Verifica che il
dato non si auto-distrugga
assegnandosi a se stesso.
Origine
=
Destinazione
Sì
No
Rilascio risorse
della destinazione
Copia risorse dell’origine
sulla destinazione
Fine
Introduzione al linguaggio C++
Assegnazione
Assegnazione
Origine
=
Destinazione
Secondo passo: Rilascio
delle
risorse
riservate
dinamicamente dai metodi
di inizializzazione della
destinazione.
Sì
No
Rilascio risorse
della destinazione
Copia risorse dell’origine
sulla destinazione
Fine
Introduzione al linguaggio C++
Assegnazione
Assegnazione
Terzo passo: Creazione di
una copia delle risorse
riservate
dinamicamente
dai
metodi
di
inizializzazione dell’origine
e loro attribuzione alla
destinazione.
Origine
=
Destinazione
Sì
No
Rilascio risorse
della destinazione
Copia risorse dell’origine
sulla destinazione
Fine
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.
3. Per ogni tipo di dato definito dal programmatore c’è un metodo
operator= specifico per quel tipo di dato.
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 dell’origine.
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.
Introduzione al linguaggio C++
Autodistruzione
Autodistruzione
Introduzione al linguaggio C++
Autodistruzione
1
2
3
4
5
6
...
7
#include “Maximum.h”
void Calcolo (void)
{
Maximum Req_Max(10); // Qty foreseen requests
Maximum Temp_Max;
// Temporary area
Req_Max = Req_Max;
...
}
Problema: Cosa succede se per errore assegnamo Req_Max a se stesso?
Introduzione al linguaggio C++
Autodistruzione
Assegnazione
Primo passo: Verifica che il
dato non si auto-distrugga
assegnandosi a se stesso.
Origine
=
Destinazione
Sì
No
Rilascio risorse
della destinazione
Copia risorse dell’origine
sulla destinazione
Cosa succederebbe se il
metodo di assegnazione
non contenesse il primo
passo di verifica?
Introduzione al linguaggio C++
Fine
Autodistruzione
Assegnazione
Origine
=
Destinazione
Secondo passo: Rilascio
delle
risorse
riservate
dinamicamente dai metodi
di inizializzazione della
destinazione.
Sì
No
Rilascio risorse
della destinazione
Copia risorse dell’origine
sulla destinazione
Senza il primo passo di
verifica, il secondo passo
rilascia le risorse riservate
dinamicamante ...
Introduzione al linguaggio C++
Fine
Autodistruzione
Assegnazione
Terzo passo: Creazione di
una copia delle risorse
riservate
dinamicamente
dai
metodi
di
inizializzazione dell’origine
e loro attribuzione alla
destinazione.
Origine
=
Destinazione
Sì
No
Rilascio risorse
della destinazione
Copia risorse dell’origine
sulla destinazione
... ed il terzo passo cerca di
copiare risorse che sono
appena state rilasciate.
Risultato ...
Introduzione al linguaggio C++
Fine
Autodistruzione
Assegnazione
Terzo passo: Creazione di
una copia delle risorse
riservate
dinamicamente
dai
metodi
di
inizializzazione dell’origine
e loro attribuzione alla
destinazione.
Origine
=
Destinazione
Sì
No
Rilascio risorse
della destinazione
Copia risorse dell’origine
sulla destinazione
Fine
Introduzione al linguaggio C++
Copia (ad uso privato)
Copia (ad uso privato)
Introduzione al linguaggio C++
Copia (ad uso privato)
Dato_del_programmatore
Inizializzazione “minima”
Inizializzazioni “migliori”
Inizializzazione per copia
Rilascio risorse impegnate
Assegnazione
6
Copia (ad uso privato)
Rilascio (ad uso privato)
Un metodo di copia (ad uso interno) viene richiamato dal metodo di
inizializzazione per copia e dal metodo di assegnazione.
Introduzione al linguaggio C++
Copia (ad uso privato)
Assegnazione
Terzo passo: Creazione di
una copia delle risorse
riservate
dinamicamente
dai
metodi
di
inizializzazione dell’origine
e loro attribuzione alla
destinazione.
Origine
=
Destinazione
Sì
No
Rilascio risorse
della destinazione
Copia risorse dell’origine
sulla destinazione
È il terzo passo del metodo
di assegnazione.
Introduzione al linguaggio C++
Fine
Rilascio (ad uso privato)
Rilascio (ad uso privato)
Introduzione al linguaggio C++
Rilascio (ad uso privato)
Dato_del_programmatore
Inizializzazione “minima”
Inizializzazioni “migliori”
Inizializzazione per copia
Rilascio risorse impegnate
Assegnazione
Copia (ad uso privato)
7
Rilascio (ad uso privato)
Un metodo di copia (ad uso interno) viene richiamato dal metodo di
inizializzazione per copia e dal metodo di assegnazione.
Introduzione al linguaggio C++
Rilascio (ad uso privato)
Assegnazione
Origine
=
Destinazione
Secondo passo: Rilascio
delle
risorse
riservate
dinamicamente dai metodi
di inizializzazione della
destinazione.
Sì
No
Rilascio risorse
della destinazione
Copia risorse dell’origine
sulla destinazione
È il secondo passo del
metodo di assegnazione.
Introduzione al linguaggio C++
Fine
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.
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.
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:[email protected]
Introduzione al linguaggio C++
Scarica

Costruzione di tipi di dati del programmatore