La presentazione è in caricamento. Aspetta per favore

La presentazione è in caricamento. Aspetta per favore

Introduzione al C++ Introduzione al linguaggio C++

Presentazioni simili


Presentazione sul tema: "Introduzione al C++ Introduzione al linguaggio C++"— Transcript della presentazione:

1 Introduzione al C++ Introduzione al linguaggio C++

2 Introduzione al C++ Introduzione al linguaggio C++ 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 C++ Modello della funzione principale ( Unix )

4 Introduzione al C++ Modello della funzione principale ( Unix ) Unix main theArg_Qty theArg_Ptr aReturn_Code

5 Introduzione al C++ Modello della funzione principale ( Unix ) Il sistema operativo Unix riconosce la funzione principale dellapplicazione da un nome riservato main. Unix main theArg_Qty theArg_Ptr aReturn_Code

6 Introduzione al C++ Modello della funzione principale ( Unix ) Lapplicazione riceve due argomenti dal sistema operativo Unix. Unix main theArg_Qty theArg_Ptr aReturn_Code

7 Introduzione al C++ Modello della funzione principale ( Unix ) Unix main theArg_Qty theArg_Ptr aReturn_Code Il primo argomento indica la quantità di parole presenti sulla linea di comando che ha richiamato lapplicazione.

8 Introduzione al C++ Modello della funzione principale ( Unix ) Il secondo argomento è un vettore che contiene le parole presenti sulla linea di comando che ha richiamato lapplicazione. Unix main theArg_Qty theArg_Ptr aReturn_Code

9 Introduzione al C++ Modello della funzione principale ( Unix ) Lapplicazione può restituire un codice di esito numerico al sistema operativo Unix. Unix main theArg_Qty theArg_Ptr aReturn_Code

10 Introduzione al C++ 1 #include "Carrello.h" 2 int main (int theArg_Qty, char **theArg_Ptr) 3 { } Modello della funzione principale ( Unix )

11 Introduzione al C++ Modello della funzione principale ( Unix ) 1 #include "Carrello.h" 2 int main (int theArg_Qty, char **theArg_Ptr) 3 { } La riga Nr. 2 contiene il modello della funzione principale dellapplicazione. Questo esempio contiene il modello usato sui sistemi Unix.

12 Introduzione al C++ Modello della funzione principale ( Unix ) 1 #include "Carrello.h" 2 int main (int theArg_Qty, char **theArg_Ptr) 3 { } Questo esempio contiene il modello usato sui sistemi Unix, e cioè definisce che: main è il nome della funzione principale dellapplicazione

13 Introduzione al C++ Modello della funzione principale ( Unix ) 1 #include "Carrello.h" 2 int main (int theArg_Qty, char **theArg_Ptr) 3 { } int è il tipo del codice di esito che lapplicazione restituisce al sistema

14 Introduzione al C++ Modello della funzione principale ( Unix ) 1 #include "Carrello.h" 2 int main (int theArg_Qty, char **theArg_Ptr) 3 { } theArg_Qty è il nome (scelto dal programmatore) del primo argomento

15 Introduzione al C++ Modello della funzione principale ( Unix ) 1 #include "Carrello.h" 2 int main (int theArg_Qty, char **theArg_Ptr) 3 { } int è il tipo dellargomento theArg_Qty Cioè largomento theArg_Qty contiene un valore intero.

16 Introduzione al C++ Modello della funzione principale ( Unix ) 1 #include "Carrello.h" 2 int main (int theArg_Qty, char **theArg_Ptr) 3 { } theArg_Ptr è il nome (scelto dal programmatore) del secondo argomento

17 Introduzione al C++ Modello della funzione principale ( Unix ) 1 #include "Carrello.h" 2 int main (int theArg_Qty, char **theArg_Ptr) 3 { } char** è il tipo dellargomento theArg_Ptr Cioè largomento theArg_Ptr è un puntatore ad un puntatore ad un valore alfanumerico.

18 Introduzione al C++ Modello della funzione principale ( Unix ) 1 #include "Carrello.h" 2 int main (int theArg_Qty, char **theArg_Ptr) 3 { } { la aperta graffa { identifica linizio di una porzione di codice

19 Introduzione al C++ Modello della funzione principale ( Unix ) 1 #include "Carrello.h" 2 int main (int theArg_Qty, char **theArg_Ptr) 3 { } Fra la aperta graffa { e la chiusa graffa } scriveremo il codice della funzione principale dellapplicazione.

20 Introduzione al C++ Modello della funzione principale ( Unix ) 1 #include "Carrello.h" 2 int main (int theArg_Qty, char **theArg_Ptr) 3 { } } la chiusa graffa } identifica la fine di una porzione di codice

21 Introduzione al C++ Modello della funzione principale ( Unix ) Riepilogo: In questa discussione abbiamo visto che: 1.Le applicazioni per il sistema Unix iniziano con la funzione principale main. 2.La funzione principale main ha due argomenti. 3.Il primo argomento è un valore intero. 4.Il secondo argomento è un puntatore ad un puntatore ad un valore alfanumerico. 5.La funzione main può restituire un codice di esito intero al sistema Unix.

22 Introduzione al C++ Dichiarazione di un oggetto ( aCarrello1 )

23 Introduzione al C++ Dichiarazione di un oggetto ( aCarrello1 ) aCarrello1 main Carrello ~Carrello Carrello itsSpesa_Qty itsSpesa Get_Peso Get_Prezzo

24 Introduzione al C++ Dichiarazione di un oggetto ( aCarrello1 ) aCarrello1 main Introduciamo nel corpo della funzione main la dichiarazione di un oggetto denominato aCarrello1 di tipo Carrello. Carrello ~Carrello Carrello itsSpesa_Qty itsSpesa Get_Peso Get_Prezzo

25 Introduzione al C++ Dichiarazione di un oggetto ( aCarrello1 ) aCarrello1 main Il compilatore C++ può compilare la funzione main poiché il modello del tipo di dato Carrello è visibile. Carrello ~Carrello Carrello itsSpesa_Qty itsSpesa Get_Peso Get_Prezzo

26 Introduzione al C++ Dichiarazione di un oggetto ( aCarrello1 ) 1 #include "Carrello.h" 2 int main (int theArg_Qty, char **theArg_Ptr) 3 { 4 Carrello aCarrello1; } Introduciamo nel corpo della funzione main la dichiarazione di un oggetto.

27 Introduzione al C++ Dichiarazione di un oggetto ( aCarrello1 ) 1 #include "Carrello.h" 2 int main (int theArg_Qty, char **theArg_Ptr) 3 { 4 Carrello aCarrello1; } La riga Nr. 4 contiene la dichiarazione delloggetto aCarrello1 del tipo (definito dal programmatore) Carrello. Come può il compilatore C++ risolvere questa definizione ?

28 Introduzione al C++ Dichiarazione di un oggetto ( aCarrello1 ) 1 #include "Carrello.h" 2 int main (int theArg_Qty, char **theArg_Ptr) 3 { 4 Carrello aCarrello1; } La riga Nr. 1 contiene un riferimento al file che contiene il modello degli oggetti di tipo (definito dal programmatore) Carrello. Come è fatto il modello di un tipo di dato definito dal programmatore?

29 Introduzione al C++ Dichiarazione di un oggetto ( aCarrello1 ) Riepilogo: In questa discussione abbiamo visto che: Carrello aCarrello1; 1.La funzione principale main contiene la dichiarazione di un oggetto di tipo Carrello. #include "Carrello.h"class Carrello 2.La funzione principale main contiene un riferimento al file dove è contenuta la definizione del tipo di dato Carrello Carrello.h.

30 Introduzione al C++ Definizione di una classe ( Carrello )

31 Introduzione al C++ Definizione di una classe ( Carrello ) aCarrello1 main Carrello ~Carrello Carrello itsSpesa_Qty itsSpesa Get_Peso Get_Prezzo Il modello del tipo di dato Carrello contiene metodi...

32 Introduzione al C++ Definizione di una classe ( Carrello ) aCarrello1 main Carrello ~Carrello Carrello itsSpesa_Qty itsSpesa Get_Peso Get_Prezzo... ed aree.

33 Introduzione al C++ Definizione di una classe ( Carrello ) aCarrello1 main Carrello ~Carrello Carrello itsSpesa_Qty itsSpesa Get_Peso Get_Prezzo Il compilatore C++ può riservare nella funzione main lo spazio necessario per contenere un dato di tipo Carrello...

34 Introduzione al C++ Definizione di una classe ( Carrello ) aCarrello1 main Carrello ~Carrello Carrello itsSpesa_Qty itsSpesa Get_Peso Get_Prezzo... poiché vede il modello del tipo di dato Carrello...

35 Introduzione al C++ Definizione di una classe ( Carrello ) aCarrello1 main Carrello ~Carrello Carrello itsSpesa_Qty itsSpesa Get_Peso Get_Prezzo... e conosce la dimensione delle aree definite nel modello.

36 Introduzione al C++ Definizione di una classe ( Carrello ) 1 #include "Pacco.h" 2 class Carrello 3 { 4 private: 5 int itsSpesa_Qty; 6 Pacco *itsSpesa[50]; 7 public: 8 Carrello (void); 9 ~Carrello (void); 10 virtual int Get_Peso (void); 11 virtual int Get_Prezzo (void); 12 }; Questo è il contenuto del file Carrello.h, a cui la funzione main faceva riferimento.

37 Introduzione al C++ Definizione di una classe ( Carrello ) 1 #include "Pacco.h" 2 class Carrello 3 { 4 private: 5 int itsSpesa_Qty; 6 Pacco *itsSpesa[50]; 7 public: 8 Carrello (void); 9 ~Carrello (void); 10 virtual int Get_Peso (void); 11 virtual int Get_Prezzo (void); 12 }; La parola riservata class dice al compilatore che inizia la definizione di un tipo di dato definito dal programmatore.

38 Introduzione al C++ Definizione di una classe ( Carrello ) 1 #include "Pacco.h" 2 class Carrello 3 { 4 private: 5 int itsSpesa_Qty; 6 Pacco *itsSpesa[50]; 7 public: 8 Carrello (void); 9 ~Carrello (void); 10 virtual int Get_Peso (void); 11 virtual int Get_Prezzo (void); 12 }; La parola (definita dal programmatore) Carrello è il nome del tipo di dato che stiamo definendo.

39 Introduzione al C++ Definizione di una classe ( Carrello ) 1 #include "Pacco.h" 2 class Carrello 3 { 4 private: 5 int itsSpesa_Qty; 6 Pacco *itsSpesa[50]; 7 public: 8 Carrello (void); 9 ~Carrello (void); 10 virtual int Get_Peso (void); 11 virtual int Get_Prezzo (void); 12 }; Queste sono definizioni di aree allinterno del tipo di dato (definito dal programmatore) Carrello.

40 Introduzione al C++ Definizione di una classe ( Carrello ) 1 #include "Pacco.h" 2 class Carrello 3 { 4 private: 5 int itsSpesa_Qty; 6 Pacco *itsSpesa[50]; 7 public: 8 Carrello (void); 9 ~Carrello (void); 10 virtual int Get_Peso (void); 11 virtual int Get_Prezzo (void); 12 }; Queste aree occupano 204 byte su di un sistema con parole di 32 bit.

41 Introduzione al C++ Definizione di una classe ( Carrello ) 1 #include "Carrello.h" 2 int main (int theArg_Qty, char **theArg_Ptr) 3 { 4 Carrello aCarrello1; } Ora il compilatore sa quanto spazio deve riservare per loggetto aCarrello1.

42 Introduzione al C++ Definizione di una classe ( Carrello ) Riepilogo: In questa discussione abbiamo visto che: Carrello aCarrello1; #include "Carrello.h"class Carrello 1.Il file Carrello.h contiene la parola riservata class seguita dal nome del tipo di dato che stiamo definendo Carrello. int itsSpesa_Qty; 2.Il compilatore può calcolare la quantità di spazio occupata dalle aree della classe Carrello. 3.Il compilatore può riservate lo spazio per loggetto aCarrello1 nella funzione main.

43 Introduzione al C++ Inizializzazione di una classe ( Carrello )

44 Introduzione al C++ Inizializzazione di una classe ( Carrello ) 1 #include "Carrello.h" 2 int main (int theArg_Qty, char **theArg_Ptr) 3 { 4 Carrello aCarrello1; } Che valore hanno le aree contenute nell'oggetto aCarrello1 dopo la sua dichiarazione?

45 Introduzione al C++ Inizializzazione di una classe ( Carrello ) aCarrello1 main Carrello ~Carrello Carrello itsSpesa_Qty itsSpesa Get_Peso Get_Prezzo Il compilatore richiama automaticamente una funzione di inizializzazione...

46 Introduzione al C++ Inizializzazione di una classe ( Carrello ) aCarrello1 main Carrello ~Carrello Carrello itsSpesa_Qty itsSpesa Get_Peso Get_Prezzo... che inizializza le aree del tipo di dato Carrello.

47 Introduzione al C++ Inizializzazione di una classe ( Carrello ) 1 #include "Pacco.h" 2 class Carrello 3 { 4 private: 5 int itsSpesa_Qty; 6 Pacco *itsSpesa[50]; 7 public: 8 Carrello (void); 9 ~Carrello (void); 10 virtual int Get_Peso (void); 11 virtual int Get_Prezzo (void); 12 }; Il compilatore richiama automaticamente una funzione di inizializzazione creata dal programmatore.

48 Introduzione al C++ Inizializzazione di una classe ( Carrello ) 1 #include "Pacco.h" 2 class Carrello 3 { 4 private: 5 int itsSpesa_Qty; 6 Pacco *itsSpesa[50]; 7 public: 8 Carrello (void); 9 ~Carrello (void); 10 virtual int Get_Peso (void); 11 virtual int Get_Prezzo (void); 12 }; Il programmatore costruisce una funzione Carrello con lo stesso nome della classe Carrello è questa la funzione di inizializzazione delle aree.

49 Introduzione al C++ Inizializzazione di una classe ( Carrello ) 1 Carrello::Carrello (void) 2 { 3 itsSpesa_Qty = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 9 itsSpesa[tIndex] = 0; 10 } Il compilatore richiama automaticamente la funzione di inizializzazione creata dal programmatore.

50 Introduzione al C++ Inizializzazione di una classe ( Carrello ) 1 Carrello::Carrello (void) 2 { 3 itsSpesa_Qty = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 9 itsSpesa[tIndex] = 0; 10 } Questa è la funzione Carrello.

51 Introduzione al C++ Inizializzazione di una classe ( Carrello ) 1 Carrello::Carrello (void) 2 { 3 itsSpesa_Qty = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 9 itsSpesa[tIndex] = 0; 10 } La funzione si applica agli oggetti di tipo Carrello.

52 Introduzione al C++ Inizializzazione di una classe ( Carrello ) 1 Carrello::Carrello (void) 2 { 3 itsSpesa_Qty = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 9 itsSpesa[tIndex] = 0; 10 } La notazione :: è un operatore di visibilità e dice che stiamo scrivendo codice che è (logicamente) dentro alla classe Carrello.

53 Introduzione al C++ Inizializzazione di una classe ( Carrello ) 1 Carrello::Carrello (void) 2 { 3 itsSpesa_Qty = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 9 itsSpesa[tIndex] = 0; 10 } In questo caso la funzione Carrello non ha bisogno di alcun argomento di ingresso.

54 Introduzione al C++ Inizializzazione di una classe ( Carrello ) 1 Carrello::Carrello (void) 2 { 3 itsSpesa_Qty = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 9 itsSpesa[tIndex] = 0; 10 } …e non emette alcun codice di esito.

55 Introduzione al C++ Inizializzazione di una classe ( Carrello ) 1 Carrello::Carrello (void) 2 { 3 itsSpesa_Qty = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 9 itsSpesa[tIndex] = 0; 10 } Inizializziamo l'area itsSpesa_Qty al valore 0 (zero). Ma dove è definita l'area itsSpesa_Qty ?

56 Introduzione al C++ Inizializzazione di una classe ( Carrello ) 1 Carrello::Carrello (void) 2 { 3 itsSpesa_Qty = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 9 itsSpesa[tIndex] = 0; 10 } L'area itsSpesa_Qty è definita nella classe Carrello.

57 Introduzione al C++ Inizializzazione di una classe ( Carrello ) aCarrello1 main Carrello ~Carrello Carrello itsSpesa_Qty itsSpesa Get_Peso Get_Prezzo L'area itsSpesa_Qty è definita nella classe Carrello.

58 Introduzione al C++ Inizializzazione di una classe ( Carrello ) 1 #include "Pacco.h" 2 class Carrello 3 { 4 private: 5 int itsSpesa_Qty; 6 Pacco *itsSpesa[50]; 7 public: 8 Carrello (void); 9 ~Carrello (void); 10 virtual int Get_Peso (void); 11 virtual int Get_Prezzo (void); 12 }; Cioè stiamo valorizzando l'area itsSpesa_Qty che ha la forma descritta qui... Ma dove è situata l'area itsSpesa_Qty ?

59 Introduzione al C++ Inizializzazione di una classe ( Carrello ) L'area itsSpesa_Qty è contenuta dentro loggetto aCarrello1, che è definito nella funzione main. aCarrello1 main Carrello ~Carrello Carrello itsSpesa_Qty itsSpesa Get_Peso Get_Prezzo

60 Introduzione al C++ Inizializzazione di una classe ( Carrello ) 1 #include "Carrello.h" 2 int main (int theArg_Qty, char **theArg_Ptr) 3 { 4 Carrello aCarrello1; } L'area itsSpesa_Qty è contenuta dentro loggetto aCarrello1, che è definito nella funzione main.

61 Introduzione al C++ Inizializzazione di una classe ( Carrello ) 1 #include "Pacco.h" 2 class Carrello 3 { 4 private: 5 int itsSpesa_Qty; 6 Pacco *itsSpesa[50]; 7 public: 8 Carrello (void); 9 ~Carrello (void); 10 virtual int Get_Peso (void); 11 virtual int Get_Prezzo (void); 12 }; Perché itsSpesa è seguito dalle parentesi quadrate? itsSpesa è un vettore che contiene 50 elementi. …proseguiamo con l'inizializzazione delle aree della classe Carrello.

62 Introduzione al C++ Inizializzazione di una classe ( Carrello ) 1 Carrello::Carrello (void) 2 { 3 itsSpesa_Qty = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 9 itsSpesa[tIndex] = 0; 10 } Come possiamo elaborare un vettore? Usiamo la dichiarazione for.

63 Introduzione al C++ Inizializzazione di una classe ( Carrello ) 1 Carrello::Carrello (void) 2 { 3 itsSpesa_Qty = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 9 itsSpesa[tIndex] = 0; 10 } Dove possiamo definire un indice temporaneo per il ciclo? Dentro il corpo della dichiarazione for, dichiariamo un indice temporaneo che ci servirà per percorrere il vettore itsSpesa e inizializzarne gli elementi.

64 Introduzione al C++ Inizializzazione di una classe ( Carrello ) 1 Carrello::Carrello (void) 2 { 3 itsSpesa_Qty = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 9 itsSpesa[tIndex] = 0; 10 } Qual'è il valore minimo che dobbiamo assegnare all'indice? È 0 (zero) e non 1.

65 Introduzione al C++ Inizializzazione di una classe ( Carrello ) 1 Carrello::Carrello (void) 2 { 3 itsSpesa_Qty = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 9 itsSpesa[tIndex] = 0; 10 } Qual'è il valore massimo che possiamo assegnare all'indice? Ce lo facciamo calcolare dal compilatore: è uguale alla lunghezza di tutto il vettore diviso la lunghezza di uno qualsiasi degli elementi.

66 Introduzione al C++ Inizializzazione di una classe ( Carrello ) 1 Carrello::Carrello (void) 2 { 3 itsSpesa_Qty = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 9 itsSpesa[tIndex] = 0; 10 } Usiamo < (minore) e non <= (minore o uguale) per fermare il ciclo for. Vi ricordate che abbiamo iniziato il ciclo con l'indice tIndex uguale a 0 (zero)?

67 Introduzione al C++ Inizializzazione di una classe ( Carrello ) 1 Carrello::Carrello (void) 2 { 3 itsSpesa_Qty = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 9 itsSpesa[tIndex] = 0; 10 } Come incrementiamo l'indice nell'elaborazione del vettore? Lo incrementiamo di un'unità alla volta con l'operatore ++.

68 Introduzione al C++ Inizializzazione di una classe ( Carrello ) 1 Carrello::Carrello (void) 2 { 3 itsSpesa_Qty = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 9 itsSpesa[tIndex] = 0; 10 } Come inizializziamo un elemento del vettore itsSpesa ? Lo inizializzamo col valore 0 (zero).

69 Introduzione al C++ Inizializzazione di una classe ( Carrello ) 1 Carrello::Carrello (void) 2 { 3 itsSpesa_Qty = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 9 itsSpesa[tIndex] = 0; 10 } Il nome del vettore itsSpesa seguito dalle aperte quadre [, dall'indice tIndex, delle chiude quadre ] è un elemento del vettore itsSpesa.

70 Introduzione al C++ Inizializzazione di una classe ( Carrello ) 1 #include "Pacco.h" 2 class Carrello 3 { 4 private: 5 int itsSpesa_Qty; 6 Pacco *itsSpesa[50]; 7 public: 8 Carrello (void); 9 ~Carrello (void); 10 virtual int Get_Peso (void); 11 virtual int Get_Prezzo (void); 12 }; Il vettore itsSpesa ha la forma definita nel corpo della classe Carrello...

71 Introduzione al C++ Inizializzazione di una classe ( Carrello ) 1 #include "Carrello.h" 2 int main (int theArg_Qty, char **theArg_Ptr) 3 { 4 Carrello aCarrello1; } … ed è contenuto dentro loggetto aCarrello1, che è definito nella funzione main.

72 Introduzione al C++ Inizializzazione di una classe ( Carrello ) Riepilogo: In questa discussione abbiamo visto che: Carrello aCarrello1; #include "Carrello.h"class Carrello void Carrello (void); 1.Il programmatore può scrivere una funzione di inizializzazione Carrello per inizializzare gli oggetti del tipo Carrello. 2.Il compilatore richiama automaticamente la funzione di inizializzazione Carrello dopo che ha riservato la quantità di spazio occupata dalle aree della classe Carrello.

73 Introduzione al C++ Puntatore ad una classe madre ( Pacco )

74 Introduzione al C++ Puntatore ad una classe madre ( Pacco ) aCarrello1 main Carrello ~Carrello Carrello itsSpesa_Qty itsSpesa Get_Peso Get_Prezzo Ogni elemento del vettore itsSpesa è di tipo Pacco. Pacco

75 Introduzione al C++ Puntatore ad una classe madre ( Pacco ) 1 #include "Pacco.h" 2 class Carrello 3 { 4 private: 5 int itsSpesa_Qty; 6 Pacco *itsSpesa[50]; 7 public: 8 Carrello (void); 9 ~Carrello (void); 10 virtual int Get_Peso (void); 11 virtual int Get_Prezzo (void); 12 }; Qual'è il tipo di un elemento del vettore itsSpesa ? Ogni elemento è un puntatore al tipo di dato (definito dal programmatore) Pacco.

76 Introduzione al C++ Puntatore ad una classe madre ( Pacco ) 1 #include "Pacco.h" 2 class Carrello 3 { 4 private: 5 int itsSpesa_Qty; 6 Pacco *itsSpesa[50]; 7 public: 8 Carrello (void); 9 ~Carrello (void); 10 virtual int Get_Peso (void); 11 virtual int Get_Prezzo (void); 12 }; L'asterisco indica che il dato è un puntatore.

77 Introduzione al C++ Puntatore ad una classe madre ( Pacco ) 1 #include "Pacco.h" 2 class Carrello 3 { 4 private: 5 int itsSpesa_Qty; 6 Pacco *itsSpesa[50]; 7 public: 8 Carrello (void); 9 ~Carrello (void); 10 virtual int Get_Peso (void); 11 virtual int Get_Prezzo (void); 12 }; Pacco è il tipo dell'oggetto puntato da ogni elemento del vettore itsSpesa.

78 Introduzione al C++ Puntatore ad una classe madre ( Pacco ) 1 #include "Pacco.h" 2 class Carrello 3 { 4 private: 5 int itsSpesa_Qty; 6 Pacco *itsSpesa[50]; 7 public: 8 Carrello (void); 9 ~Carrello (void); 10 virtual int Get_Peso (void); 11 virtual int Get_Prezzo (void); 12 }; Dove è contenuta la definizione del tipo di dato Pacco ? La riga Nr. 1 è il riferimento al file Pacco.h che contiene la definizione del tipo di dato Pacco.

79 Introduzione al C++ Puntatore ad una classe madre ( Pacco ) Riepilogo: In questa discussione abbiamo visto che: Pacco *itsSpesa; #include "Pacco.h"class Pacco 1.Il programmatore può definire un tipo di dato Pacco. 2.La classe Carrello contiene un vettore di puntatori al tipo di dato Pacco. 3.La classe Carrello contiene un riferimento al file che contiene la definizione della classe Pacco Pacco.h.

80 Introduzione al C++ Definizione di una classe madre ( Pacco )

81 Introduzione al C++ Definizione di una classe madre ( Pacco ) itsSpesa Get_Prezzo itsSpesa_Qty Carrello ~Carrello Get_Peso Pacco ~Pacco Pacco itsPeso itsPrezzo Get_Peso Get_Prezzo

82 Introduzione al C++ Definizione di una classe madre ( Pacco ) itsSpesa Get_Prezzo itsSpesa_Qty Carrello ~Carrello Get_Peso Pacco ~Pacco Pacco itsPeso itsPrezzo Get_Peso Get_Prezzo Il programmatore può definire nel modello del tipo di dato Carrello un puntatore ad un vettore di elementi di tipo Pacco...

83 Introduzione al C++ Definizione di una classe madre ( Pacco ) itsSpesa Get_Prezzo itsSpesa_Qty Carrello ~Carrello Get_Peso Pacco ~Pacco Pacco itsPeso itsPrezzo Get_Peso Get_Prezzo... poiché vede il modello del tipo di dato Pacco.

84 Introduzione al C++ Definizione di una classe madre ( Pacco ) itsSpesa Get_Prezzo itsSpesa_Qty Carrello ~Carrello Get_Peso Pacco ~Pacco Pacco itsPeso itsPrezzo Get_Peso Get_Prezzo Il modello del tipo di dato Pacco contiene metodi...

85 Introduzione al C++ Definizione di una classe madre ( Pacco ) itsSpesa Get_Prezzo itsSpesa_Qty Carrello ~Carrello Get_Peso Pacco ~Pacco Pacco itsPeso itsPrezzo Get_Peso Get_Prezzo... ed aree.

86 Introduzione al C++ Definizione di una classe madre ( Pacco ) 1 class Pacco 2 { 3 private: 4 int itsPeso; 5 int itsPrezzo; 6 protected: 7 Pacco (void); 8 ~Pacco (void); 9 public: 9 virtual int Get_Peso (void); 10 virtual int Get_Prezzo (void); 11 }; Questa è la definizione del tipo di dato (definito dal programmatore) Pacco.

87 Introduzione al C++ Definizione di una classe madre ( Pacco ) 1 class Pacco 2 { 3 private: 4 int itsPeso; 5 int itsPrezzo; 6 protected: 7 Pacco (void); 8 ~Pacco (void); 9 public: 9 virtual int Get_Peso (void); 10 virtual int Get_Prezzo (void); 11 }; La definizione inizia con la parola riservata class.

88 Introduzione al C++ Definizione di una classe madre ( Pacco ) 1 class Pacco 2 { 3 private: 4 int itsPeso; 5 int itsPrezzo; 6 protected: 7 Pacco (void); 8 ~Pacco (void); 9 public: 9 virtual int Get_Peso (void); 10 virtual int Get_Prezzo (void); 11 }; La parola riservata class è seguita dal nome del tipo di dato (definito dal programmatore) che stiamo definendo Pacco.

89 Introduzione al C++ Definizione di una classe madre ( Pacco ) 1 class Pacco 2 { 3 private: 4 int itsPeso; 5 int itsPrezzo; 6 protected: 7 Pacco (void); 8 ~Pacco (void); 9 public: 9 virtual int Get_Peso (void); 10 virtual int Get_Prezzo (void); 11 }; La parola riservata private è un operatore di visibilità. Le aree e i metodi privati possono essere usati solamente dai metodi della classe Pacco stessa.

90 Introduzione al C++ Definizione di una classe madre ( Pacco ) 1 class Pacco 2 { 3 private: 4 int itsPeso; 5 int itsPrezzo; 6 protected: 7 Pacco (void); 8 ~Pacco (void); 9 public: 9 virtual int Get_Peso (void); 10 virtual int Get_Prezzo (void); 11 }; Le aree itsPeso e itsPrezzo sono aree private della classe Pacco.

91 Introduzione al C++ Definizione di una classe madre ( Pacco ) 1 class Pacco 2 { 3 private: 4 int itsPeso; 5 int itsPrezzo; 6 protected: 7 Pacco (void); 8 ~Pacco (void); 9 public: 9 virtual int Get_Peso (void); 10 virtual int Get_Prezzo (void); 11 }; La parola riservata protected è un operatore di visibilità. Le aree e i metodi protetti possono essere usati solamente dai metodii della classe Pacco stessa o delle classi figlie.

92 Introduzione al C++ Definizione di una classe madre ( Pacco ) 1 class Pacco 2 { 3 private: 4 int itsPeso; 5 int itsPrezzo; 6 protected: 7 Pacco (void); 8 ~Pacco (void); 9 public: 9 virtual int Get_Peso (void); 10 virtual int Get_Prezzo (void); 11 }; I metodi Pacco e ~Pacco sono metodi protetti della classe Pacco.

93 Introduzione al C++ Definizione di una classe madre ( Pacco ) 1 class Pacco 2 { 3 private: 4 int itsPeso; 5 int itsPrezzo; 6 protected: 7 Pacco (void); 8 ~Pacco (void); 9 public: 9 virtual int Get_Peso (void); 10 virtual int Get_Prezzo (void); 11 }; La parola riservata public è un operatore di visibilità. Le aree e i metodi publici possono essere usati da qualunque metodo o funzione dell'applicazione.

94 Introduzione al C++ Definizione di una classe madre ( Pacco ) 1 class Pacco 2 { 3 private: 4 int itsPeso; 5 int itsPrezzo; 6 protected: 7 Pacco (void); 8 ~Pacco (void); 9 public: 9 virtual int Get_Peso (void); 10 virtual int Get_Prezzo (void); 11 }; I metodi Get_Peso e Get_Prezzo sono metodi pubblici della classe Pacco.

95 Introduzione al C++ Definizione di una classe madre ( Pacco ) Riepilogo: In questa discussione abbiamo visto che: class Pacco private: 1.Il programmatore può definire dentro il tipo di dato Pacco aree e metodi visibili solamente dai metodii di Pacco. protected: 2.Il programmatore può definire dentro il tipo di dato Pacco aree e metodi visibili solamente dai metodi di Pacco e dai metodi delle classi figlie. 3.Il programmatore può definire dentro il tipo di dato Pacco aree e metodi visibili da qualunque metodo o funzione dell'applicazione. public:

96 Introduzione al C++ Inizializzazione di una classe madre ( Pacco )

97 Introduzione al C++ Inizializzazione di una classe madre ( Pacco ) itsSpesa Get_Prezzo itsSpesa_Qty Carrello ~Carrello Get_Peso Pacco ~Pacco Pacco itsPeso itsPrezzo Get_Peso Get_Prezzo Quando viene creato un elemento del vettore il compilatore richiama una funzione di inizializzazione...

98 Introduzione al C++ Inizializzazione di una classe madre ( Pacco ) itsSpesa Get_Prezzo itsSpesa_Qty Carrello ~Carrello Get_Peso Pacco ~Pacco Pacco itsPeso itsPrezzo Get_Peso Get_Prezzo... che inizializza le aree del tipo di dato Pacco.

99 Introduzione al C++ Inizializzazione di una classe madre ( Pacco ) 1 class Pacco 2 { 3 private: 4 int itsPeso; 5 int itsPrezzo; 6 protected: 7 Pacco (void); 8 ~Pacco (void); 9 public: 9 virtual int Get_Peso (void); 10 virtual int Get_Prezzo (void); 11 }; Questo è il modello di un metodo di inizializzazione degli oggetti di tipo (definito dal programmatore) Pacco.

100 Introduzione al C++ Inizializzazione di una classe madre ( Pacco ) 1 class Pacco 2 { 3 private: 4 int itsPeso; 5 int itsPrezzo; 6 protected: 7 Pacco (void); 8 ~Pacco (void); 9 public: 9 virtual int Get_Peso (void); 10 virtual int Get_Prezzo (void); 11 }; Il metodo deve chiamarsi come il nome del tipo di dato Pacco.

101 Introduzione al C++ Inizializzazione di una classe madre ( Pacco ) 1 Pacco::Pacco (void) 2 { 4 itsPeso = 0; 5 itsPrezzo = 0; 6 } Questo è il corpo di un metodo di inizializzazione degli oggetti di tipo (definito dal programmatore) Pacco.

102 Introduzione al C++ Inizializzazione di una classe madre ( Pacco ) 1 Pacco::Pacco (void) 2 { 4 itsPeso = 0; 5 itsPrezzo = 0; 6 } Il metodo Pacco appartiene alla classe Pacco.

103 Introduzione al C++ Inizializzazione di una classe madre ( Pacco ) 1 Pacco::Pacco (void) 2 { 4 itsPeso = 0; 5 itsPrezzo = 0; 6 } Le aree che inizializziamo – itsPeso e itsPrezzo – sono contenute dentro gli oggetti di tipo Pacco.

104 Introduzione al C++ Inizializzazione di una classe madre ( Pacco ) Riepilogo: In questa discussione abbiamo visto che: 1.Il programmatore costruisce un metodo per inizializzare le aree degli oggetti di tipo Pacco. 2.Il metodo di inizializzazione deve chiamarsi come il tipo di dato definito dal programmatore Pacco. 3.Il programmatore può valorizzare le aree definite nella classe Pacco semplicemente utilizzando il loro nome. 4.Le aree appartengono implicitamente alla classe Pacco poiché il nome del metodo Pacco è preceduto dall'operatore di visibilità Pacco::.

105 Introduzione al C++ Richiamo di un metodo ( Get_Peso )

106 Introduzione al C++ Richiamo di un metodo ( Get_Peso ) aCarrello1 main Carrello ~Carrello Carrello itsSpesa_Qty itsSpesa Get_Peso Get_Prezzo Inseriamo nella funzione main il richiamo ad un metodo della classe Carrello. Pacco

107 Introduzione al C++ Richiamo di un metodo ( Get_Peso ) 1 #include 2 #include "Carrello.h" 3 int main (int theArg_Qty, char **theArg_Ptr) 4 { 5 Carrello aCarrello1; int aTot_Peso = aCarrello1.Get_Peso(); 8 printf ("Peso totale = %i\n", aTot_Peso); } Inseriamo nella funzione main il richiamo ad un metodo della classe Carrello.

108 Introduzione al C++ Richiamo di un metodo ( Get_Peso ) 1 #include 2 #include "Carrello.h" 3 int main (int theArg_Qty, char **theArg_Ptr) 4 { 5 Carrello aCarrello1; int aTot_Peso = aCarrello1.Get_Peso(); 8 printf ("Peso totale = %i\n", aTot_Peso); } Richiamiamo il metodo Get_Peso dell'oggetto aCarrello1.

109 Introduzione al C++ Richiamo di un metodo ( Get_Peso ) 1 #include 2 #include "Carrello.h" 3 int main (int theArg_Qty, char **theArg_Ptr) 4 { 5 Carrello aCarrello1; int aTot_Peso = aCarrello1.Get_Peso(); 8 printf ("Peso totale = %i\n", aTot_Peso); } Le parentesi tonde () indicano che Get_Peso è un metodo.

110 Introduzione al C++ Richiamo di un metodo ( Get_Peso ) 1 #include "Pacco.h" 2 class Carrello 3 { 4 private: 5 int itsSpesa_Qty; 6 Pacco *itsSpesa[50]; 7 public: 8 Carrello (void); 9 ~Carrello (void); 10 virtual int Get_Peso (void); 11 virtual int Get_Prezzo (void); 12 }; Le parentesi del richiamo non contengono valori poiché il metodo Get_Peso non ha bisogno di argomenti.

111 Introduzione al C++ Richiamo di un metodo ( Get_Peso ) 1 #include "Pacco.h" 2 class Carrello 3 { 4 private: 5 int itsSpesa_Qty; 6 Pacco *itsSpesa[50]; 7 public: 8 Carrello (void); 9 ~Carrello (void); 10 virtual int Get_Peso (void); 11 virtual int Get_Prezzo (void); 12 }; Il metodo Get_Peso può essere richiamato dalla funzione main poiché è pubblico.

112 Introduzione al C++ Richiamo di un metodo ( Get_Peso ) 1 #include 2 #include "Carrello.h" 3 int main (int theArg_Qty, char **theArg_Ptr) 4 { 5 Carrello aCarrello1; int aTot_Peso = aCarrello1.Get_Peso(); 8 printf ("Peso totale = %i\n", aTot_Peso); } Il metodo lavora sulle aree dell'oggetto aCarrello1.

113 Introduzione al C++ Richiamo di un metodo ( Get_Peso ) 1 #include "Pacco.h" 2 class Carrello 3 { 4 private: 5 int itsSpesa_Qty; 6 Pacco *itsSpesa[50]; 7 public: 8 Carrello (void); 9 ~Carrello (void); 10 virtual int Get_Peso (void); 11 virtual int Get_Prezzo (void); 12 }; Il metodo Get_Peso restituisce un valore intero.

114 Introduzione al C++ Richiamo di un metodo ( Get_Peso ) 1 #include 2 #include "Carrello.h" 3 int main (int theArg_Qty, char **theArg_Ptr) 4 { 5 Carrello aCarrello1; int aTot_Peso = aCarrello1.Get_Peso(); 8 printf ("Peso totale = %i\n", aTot_Peso); } Il risultato intero del metodo Get_Peso valorizza l'area aTot_Peso di tipo intero.

115 Introduzione al C++ Richiamo di un metodo ( Get_Peso ) Riepilogo: In questa discussione abbiamo visto che: 1.La funzione main può richiamare metodi pubblici dell'oggetto aCarrello1. 2.Occorre usare le parentesi tonde anche se il metodo Get_Peso non ha bisogno di argomenti. 3.Il metodo Get_Peso lavora sulle aree contenute nell'oggetto aCarrello1. 4.Il metodo Get_Peso restituisce un valore intero, che valorizza l'area aTot_Peso.

116 Introduzione al C++ Stampa di un valore

117 Introduzione al C++ Stampa di un valore 1 #include 2 #include "Carrello.h" 3 int main (int theArg_Qty, char **theArg_Ptr) 4 { 5 Carrello aCarrello1; int aTot_Peso = aCarrello1.Get_Peso(); 8 printf ("Peso totale = %i\n", aTot_Peso); } Il risultato intero del metodo Get_Peso valorizza l'area aTot_Peso di tipo intero. L'area aTot_Peso è definita dal compilatore dentro la funzione main, ed è disponibile dalla riga Nr. 7 fino alla fine della funzione main.

118 Introduzione al C++ Stampa di un valore 1 #include 2 #include "Carrello.h" 3 int main (int theArg_Qty, char **theArg_Ptr) 4 { 5 Carrello aCarrello1; int aTot_Peso = aCarrello1.Get_Peso(); 8 printf ("Peso totale = %i\n", aTot_Peso); } Usiamo la funzione di sistema printf per stampare il valore di aTot_Peso. Come può il compilatore risolvere il riferimento alla funzione printf ?.

119 Introduzione al C++ Stampa di un valore 1 #include 2 #include "Carrello.h" 3 int main (int theArg_Qty, char **theArg_Ptr) 4 { 5 Carrello aCarrello1; int aTot_Peso = aCarrello1.Get_Peso(); 8 printf ("Peso totale = %i\n", aTot_Peso); } La riga Nr. 1 è un riferimento al file che contiene il modello della funzione printf. Il modello della funzione printf deve essere visibile anche se è una funzione fornita dal sistema.

120 Introduzione al C++ Stampa di un valore 1 #include 2 #include "Carrello.h" 3 int main (int theArg_Qty, char **theArg_Ptr) 4 { 5 Carrello aCarrello1; int aTot_Peso = aCarrello1.Get_Peso(); 8 printf ("Peso totale = %i\n", aTot_Peso); } Il primo argomento della funzione printf è un modello del testo che verrà stampato.

121 Introduzione al C++ Stampa di un valore 1 #include 2 #include "Carrello.h" 3 int main (int theArg_Qty, char **theArg_Ptr) 4 { 5 Carrello aCarrello1; int aTot_Peso = aCarrello1.Get_Peso(); 8 printf ("Peso totale = %i\n", aTot_Peso); } % è un segnaposto che indica la posizione dove deve essere sostituito il secondo argomento aTot_Peso. i indica alla funzione printf che aTot_Peso è un valore intero.

122 Introduzione al C++ Stampa di un valore 1 #include 2 #include "Carrello.h" 3 int main (int theArg_Qty, char **theArg_Ptr) 4 { 5 Carrello aCarrello1; int aTot_Peso = aCarrello1.Get_Peso(); 8 printf ("Peso totale = %i\n", aTot_Peso); } Il secondo argomento aTot_Peso contiene il valore intero che sostituisce il segnaposto %i.

123 Introduzione al C++ Stampa di un valore 1 #include 2 #include "Carrello.h" 3 int main (int theArg_Qty, char **theArg_Ptr) 4 { 5 Carrello aCarrello1; int aTot_Peso = aCarrello1.Get_Peso(); 8 printf ("Peso totale = %i\n", aTot_Peso); } Inserendo nel modello della riga di stampa un \n si richiede un salto a nuova riga.

124 Introduzione al C++ Stampa di un valore Riepilogo: In questa discussione abbiamo visto che: 1.Possiamo stampare valori con la funzione di sistema printf. 2.Anche se printf è una funzione di sistema occorre fornire un modello della funzione al compilatore. 3.Il primo argomento della funzione printf è il modello della riga di stampa. 4.Possiamo indicare dove vogliamo inserire i valori nel modello mediante segnaposti. 5.I segnaposti contengono un carattere che indica il formato dell'area che contiene il valore da stampare.

125 Introduzione al C++ Corpo di un metodo ( Get_Peso )

126 Introduzione al C++ Corpo di un metodo ( Get_Peso ) Richiamiamo il metodo Get_Peso dell'oggetto aCarrello1 per calcolare il peso del carrello della spesa. aCarrello1 main Carrello ~Carrello Carrello itsSpesa_Qty itsSpesa Get_Peso Get_Prezzo

127 Introduzione al C++ Corpo di un metodo ( Get_Peso ) 1 #include 2 #include "Carrello.h" 3 int main (int theArg_Qty, char **theArg_Ptr) 4 { 5 Carrello aCarrello1; int aTot_Peso = aCarrello1.Get_Peso(); 8 printf ("Peso totale = %i\n", aTot_Peso); } Richiamiamo il metodo Get_Peso dell'oggetto aCarrello1 per calcolare il peso del carrello della spesa.

128 Introduzione al C++ Corpo di un metodo ( Get_Peso ) 1 int Carrello::Get_Peso (void) 2 { 3 int aTot_Peso = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 8 if (!itsSpesa[tIndex]) break; 9 aTot_Peso += itsSpesa[tIndex]->Get_Peso(); 10 } 11 return aTot_Peso; 12 } Stiamo scrivendo il corpo di un metodo Get_Peso.

129 Introduzione al C++ Corpo di un metodo ( Get_Peso ) 1 int Carrello::Get_Peso (void) 2 { 3 int aTot_Peso = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 8 if (!itsSpesa[tIndex]) break; 9 aTot_Peso += itsSpesa[tIndex]->Get_Peso(); 10 } 11 return aTot_Peso; 12 } Il metodo appartiene alla classe Carrello...

130 Introduzione al C++ Corpo di un metodo ( Get_Peso ) … di conseguenza legge e modifica le aree della classe Carrello... aCarrello1 main Carrello ~Carrello Carrello itsSpesa_Qty itsSpesa Get_Peso Get_Prezzo

131 Introduzione al C++ Corpo di un metodo ( Get_Peso ) 1 int Carrello::Get_Peso (void) 2 { 3 int aTot_Peso = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 8 if (!itsSpesa[tIndex]) break; 9 aTot_Peso += itsSpesa[tIndex]->Get_Peso(); 10 } 11 return aTot_Peso; 12 } … di conseguenza legge e modifica le aree della classe Carrello...

132 Introduzione al C++ Corpo di un metodo ( Get_Peso ) … che sono contenute nell'oggetto aCarrello1... aCarrello1 main Carrello ~Carrello Carrello itsSpesa_Qty itsSpesa Get_Peso Get_Prezzo

133 Introduzione al C++ Corpo di un metodo ( Get_Peso ) 1 #include 2 #include "Carrello.h" 3 int main (int theArg_Qty, char **theArg_Ptr) 4 { 5 Carrello aCarrello1; int aTot_Peso = aCarrello1.Get_Peso(); 8 printf ("Peso totale = %i\n", aTot_Peso); } … che sono contenute nell'oggetto aCarrello1...

134 Introduzione al C++ Corpo di un metodo ( Get_Peso ) 1 #include 2 #include "Carrello.h" 3 int main (int theArg_Qty, char **theArg_Ptr) 4 { 5 Carrello aCarrello1; int aTot_Peso = aCarrello1.Get_Peso(); 8 printf ("Peso totale = %i\n", aTot_Peso); } … che è dichiarato nella funzione main.

135 Introduzione al C++ Corpo di un metodo ( Get_Peso ) 1 int Carrello::Get_Peso (void) 2 { 3 int aTot_Peso = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 8 if (!itsSpesa[tIndex]) break; 9 aTot_Peso += itsSpesa[tIndex]->Get_Peso(); 10 } 11 return aTot_Peso; 12 } Dichiariamo un'area aTot_Peso e la inizializziamo a 0 (zero).

136 Introduzione al C++ Corpo di un metodo ( Get_Peso ) 1 int Carrello::Get_Peso (void) 2 { 3 int aTot_Peso = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 8 if (!itsSpesa[tIndex]) break; 9 aTot_Peso += itsSpesa[tIndex]->Get_Peso(); 10 } 11 return aTot_Peso; 12 } Elaboriamo in ciclo gli elementi del vettore itsSpesa con la dichiarazione for.

137 Introduzione al C++ Corpo di un metodo ( Get_Peso ) 1 int Carrello::Get_Peso (void) 2 { 3 int aTot_Peso = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 8 if (!itsSpesa[tIndex]) break; 9 aTot_Peso += itsSpesa[tIndex]->Get_Peso(); 10 } 11 return aTot_Peso; 12 } Dichiariamo un'indice di servizio tIndex per elaborare in ciclo gli elementi del vettore itsSpesa.

138 Introduzione al C++ Corpo di un metodo ( Get_Peso ) 1 int Carrello::Get_Peso (void) 2 { 3 int aTot_Peso = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 8 if (!itsSpesa[tIndex]) break; 9 aTot_Peso += itsSpesa[tIndex]->Get_Peso(); 10 } 11 return aTot_Peso; 12 } Inizializziamo l'indice di servizio tIndex a 0 (zero).

139 Introduzione al C++ Corpo di un metodo ( Get_Peso ) 1 int Carrello::Get_Peso (void) 2 { 3 int aTot_Peso = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 8 if (!itsSpesa[tIndex]) break; 9 aTot_Peso += itsSpesa[tIndex]->Get_Peso(); 10 } 11 return aTot_Peso; 12 } Dopo ogni ciclo incrementiamo l'indice di servizio tIndex, sommando 1 con l'operatore ++.

140 Introduzione al C++ Corpo di un metodo ( Get_Peso ) 1 int Carrello::Get_Peso (void) 2 { 3 int aTot_Peso = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 8 if (!itsSpesa[tIndex]) break; 9 aTot_Peso += itsSpesa[tIndex]->Get_Peso(); 10 } 11 return aTot_Peso; 12 } Fermiamo il ciclo quando non è più vero che l'indice è minore della quantità di elementi contenuti nel vettore...

141 Introduzione al C++ Corpo di un metodo ( Get_Peso ) 1 int Carrello::Get_Peso (void) 2 { 3 int aTot_Peso = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 8 if (!itsSpesa[tIndex]) break; 9 aTot_Peso += itsSpesa[tIndex]->Get_Peso(); 10 } 11 return aTot_Peso; 12 } …oppure quando incontriamo il primo elemento ancora inizializzato a 0 (zero).

142 Introduzione al C++ Corpo di un metodo ( Get_Peso ) 1 int Carrello::Get_Peso (void) 2 { 3 int aTot_Peso = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 8 if (!itsSpesa[tIndex]) break; 9 aTot_Peso += itsSpesa[tIndex]->Get_Peso(); 10 } 11 return aTot_Peso; 12 } Appena entrati nel ciclo valutiamo l'elemento corrente del vettore itsSpesa itsSpesa[tIndex].

143 Introduzione al C++ Corpo di un metodo ( Get_Peso ) 1 int Carrello::Get_Peso (void) 2 { 3 int aTot_Peso = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 8 if (!itsSpesa[tIndex]) break; 9 aTot_Peso += itsSpesa[tIndex]->Get_Peso(); 10 } 11 return aTot_Peso; 12 } Se l'elemento itsSpesa[tIndex] è ancora inizializzato a 0 (zero), il suo complemento !itsSpesa[tIndex] vale 1...

144 Introduzione al C++ Corpo di un metodo ( Get_Peso ) 1 int Carrello::Get_Peso (void) 2 { 3 int aTot_Peso = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 8 if (!itsSpesa[tIndex]) break; 9 aTot_Peso += itsSpesa[tIndex]->Get_Peso(); 10 } 11 return aTot_Peso; 12 } … di conseguenza l'espressione logica (!itsSpesa[tIndex]) è vera...

145 Introduzione al C++ Corpo di un metodo ( Get_Peso ) 1 int Carrello::Get_Peso (void) 2 { 3 int aTot_Peso = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 8 if (!itsSpesa[tIndex]) break; 9 aTot_Peso += itsSpesa[tIndex]->Get_Peso(); 10 } 11 return aTot_Peso; 12 } … e la dichiarazione break fa terminare il ciclo for anticipatamente.

146 Introduzione al C++ Corpo di un metodo ( Get_Peso ) 1 int Carrello::Get_Peso (void) 2 { 3 int aTot_Peso = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 8 if (!itsSpesa[tIndex]) break; 9 aTot_Peso += itsSpesa[tIndex]->Get_Peso(); 10 } 11 return aTot_Peso; 12 } Alla fine del ciclo for, l'area aTot_Peso contiene la somma dei pesi di tutti gli elementi del vettore itsSpesa.

147 Introduzione al C++ Corpo di un metodo ( Get_Peso ) 1 int Carrello::Get_Peso (void) 2 { 3 int aTot_Peso = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 8 if (!itsSpesa[tIndex]) break; 9 aTot_Peso += itsSpesa[tIndex]->Get_Peso(); 10 } 11 return aTot_Peso; 12 } Il metodo Get_Peso restituisce il valore aTot_Peso con la dichiarazione return.

148 Introduzione al C++ Corpo di un metodo ( Get_Peso ) 1 int Carrello::Get_Peso (void) 2 { 3 int aTot_Peso = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 8 if (!itsSpesa[tIndex]) break; 9 aTot_Peso += itsSpesa[tIndex]->Get_Peso(); 10 } 11 return aTot_Peso; 12 } Il valore di aTot_Peso è il valore intero che il metodo Get_Peso restituisce...

149 Introduzione al C++ Corpo di un metodo ( Get_Peso ) 1 #include 2 #include "Carrello.h" 3 int main (int theArg_Qty, char **theArg_Ptr) 4 { 5 Carrello aCarrello1; int aTot_Peso = aCarrello1.Get_Peso(); 8 printf ("Peso totale = %i\n", aTot_Peso); } … e che valorizza l'area aTot_Peso dichiarata nella funzione main.

150 Introduzione al C++ Corpo di un metodo ( Get_Peso ) 1 int Carrello::Get_Peso (void) 2 { 3 int aTot_Peso = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 8 if (!itsSpesa[tIndex]) break; 9 aTot_Peso += itsSpesa[tIndex]->Get_Peso(); 10 } 11 return aTot_Peso; 12 } Come abbiamo calcolato la somma dei pesi aTot_Peso ?

151 Introduzione al C++ Corpo di un metodo ( Get_Peso ) 1 int Carrello::Get_Peso (void) 2 { 3 int aTot_Peso = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 8 if (!itsSpesa[tIndex]) break; 9 aTot_Peso += itsSpesa[tIndex]->Get_Peso(); 10 } 11 return aTot_Peso; 12 } L'operatore += incrementa ad ogni ciclo l'area aTot_Peso della quantità calcolata dal metodo Get_Peso a secondo membro...

152 Introduzione al C++ Corpo di un metodo ( Get_Peso ) 1 int Carrello::Get_Peso (void) 2 { 3 int aTot_Peso = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 8 if (!itsSpesa[tIndex]) break; 9 aTot_Peso += itsSpesa[tIndex]->Get_Peso(); 10 } 11 return aTot_Peso; 12 } …senza perdere il valore precedente di aTot_Peso...

153 Introduzione al C++ Corpo di un metodo ( Get_Peso ) 1 int Carrello::Get_Peso (void) 2 { 3 int aTot_Peso = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 8 if (!itsSpesa[tIndex]) break; 9 aTot_Peso += itsSpesa[tIndex]->Get_Peso(); 10 } 11 return aTot_Peso; 12 } …come se avessimo scritto: aTot_Peso = aTot_Peso + itsSpesa[tIndex]->Get_Peso();

154 Introduzione al C++ Corpo di un metodo ( Get_Peso ) 1 int Carrello::Get_Peso (void) 2 { 3 int aTot_Peso = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 8 if (!itsSpesa[tIndex]) break; 9 aTot_Peso += itsSpesa[tIndex]->Get_Peso(); 10 } 11 return aTot_Peso; 12 } itsSpesa[tIndex] è l'elemento corrente del vettore itsSpesa, e cioè è il puntatore all'oggetto di tipo Pacco puntato da quell'elemento.

155 Introduzione al C++ Corpo di un metodo ( Get_Peso ) 1 int Carrello::Get_Peso (void) 2 { 3 int aTot_Peso = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 8 if (!itsSpesa[tIndex]) break; 9 aTot_Peso += itsSpesa[tIndex]->Get_Peso(); 10 } 11 return aTot_Peso; 12 } Ma che cosa è Get_Peso ?

156 Introduzione al C++ Corpo di un metodo ( Get_Peso ) 1 int Carrello::Get_Peso (void) 2 { 3 int aTot_Peso = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 8 if (!itsSpesa[tIndex]) break; 9 aTot_Peso += itsSpesa[tIndex]->Get_Peso(); 10 } 11 return aTot_Peso; 12 } L'operatore -> indirizza un'area oppure un metodo dell'oggetto di tipo Pacco puntato dall'elemento del vettore itsSpesa.

157 Introduzione al C++ Corpo di un metodo ( Get_Peso ) 1 class Pacco 2 { 3 private: 4 int itsPeso; 5 int itsPrezzo; 6 protected: 7 Pacco (void); 8 ~Pacco (void); 9 public: 9 virtual int Get_Peso (void); 10 virtual int Get_Prezzo (void); 11 }; Il puntatore ad un oggetto di tipo Pacco richiama il metodo Get_Peso della classe Pacco.

158 Introduzione al C++ Corpo di un metodo ( Get_Peso ) Riepilogo: In questa discussione abbiamo visto che: 1.Con la dichiarazione for possiamo elaborare gli elementi del vettore itsSpesa. 2.Ogni elemento del vettore itsSpesa contiene un puntatore ad un oggetto di tipo Pacco. 3.Noto il puntatore, possiamo indirizzare aree e metodi di un oggetto con l'operatore -> 4.Possiamo incrementare un totale con l'operatore +=, senza bisogno di riscrivere a secondo membro il nome dell'area di destinazione. 5.Possiamo restituire alla funzione chiamante un valore calcolato all'interno di un metodo.

159 Introduzione al C++ Utilizzo di una classe madre ( Pacco )

160 Introduzione al C++ Utilizzo di una classe madre ( Pacco ) Scriviamo il corpo del metodo Get_Peso della classe Pacco. Get_Peso Get_Prezzo Pacco Get_Peso Miele itsPeso itsPrezzo Get_Prezzo Get_Peso Latte Get_Prezzo

161 Introduzione al C++ Utilizzo di una classe madre ( Pacco ) 1 class Pacco 2 { 3 private: 4 int itsPeso; 5 int itsPrezzo; 6 protected: 7 Pacco (void); 8 ~Pacco (void); 9 public: 9 virtual int Get_Peso (void); 10 virtual int Get_Prezzo (void); 11 }; Scriviamo il corpo del metodo Get_Peso della classe Pacco.

162 Introduzione al C++ Utilizzo di una classe madre ( Pacco ) 1 int Pacco::Get_Peso (void) 2 { 3 return itsPeso; 4 } Scriviamo il corpo del metodo Get_Peso...

163 Introduzione al C++ Utilizzo di una classe madre ( Pacco ) 1 int Pacco::Get_Peso (void) 2 { 3 return itsPeso; 4 } …che appartiene alla classe Pacco.

164 Introduzione al C++ Utilizzo di una classe madre ( Pacco ) 1 int Pacco::Get_Peso (void) 2 { 3 return itsPeso; 4 } La dichiarazione return restituisce il valore dell'area privata itsPeso che non era visibile dall'esterno della classe Pacco...

165 Introduzione al C++ Utilizzo di una classe madre ( Pacco ) 1 int Pacco::Get_Peso (void) 2 { 3 return itsPeso; 4 } …ma che ora è diventato il valore intero restituito dal metodo pubblico Get_Peso...

166 Introduzione al C++ Utilizzo di una classe madre ( Pacco ) 1 int Carrello::Get_Peso (void) 2 { 3 int aTot_Peso = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 8 if (!itsSpesa[tIndex]) break; 9 aTot_Peso += itsSpesa[tIndex]->Get_Peso(); 10 } 11 return aTot_Peso; 12 } …che può venire sommato all'area aTot_Peso ad ogni ciclo nel metodo Get_Peso della classe Carrello.

167 Introduzione al C++ Utilizzo di una classe madre ( Pacco ) 1 void Pacco::Pacco (void) 2 { 4 itsPeso = 0; 5 itsPrezzo = 0; 6 } Ma nel metodo di inizializzazione della classe Pacco non avevamo assegnato il valore 0 (zero) all'area itsPeso ? Ma allora a cosa serve la classe Pacco?

168 Introduzione al C++ Utilizzo di una classe madre ( Pacco ) 1 class Pacco 2 { 3 private: 4 int itsPeso; 5 int itsPrezzo; 6 protected: 7 Pacco (void); 8 ~Pacco (void); 9 public: 9 virtual int Get_Peso (void); 10 virtual int Get_Prezzo (void); 11 }; Il metodo Get_Peso della classe madre Pacco è un metodo scavalcabile dai metodi Get_Peso delle classi figlie.

169 Introduzione al C++ Utilizzo di una classe madre ( Pacco ) 1 class Pacco 2 { 3 private: 4 int itsPeso; 5 int itsPrezzo; 6 protected: 7 Pacco (void); 8 ~Pacco (void); 9 public: 9 virtual int Get_Peso (void); 10 virtual int Get_Prezzo (void); 11 }; La parola riservata virtual dichiara che il metodo Get_Peso della classe madre Pacco è un metodo scavalcabile dai metodi Get_Peso delle classi figlie.

170 Introduzione al C++ Utilizzo di una classe madre ( Pacco ) 1 class Pacco 2 { 3 private: 4 int itsPeso; 5 int itsPrezzo; 6 protected: 7 Pacco (void); 8 ~Pacco (void); 9 public: 9 virtual int Get_Peso (void); 10 virtual int Get_Prezzo (void); 11 }; Un metodo Get_Peso di una classe figlia può scavalcare il metodo Get_Peso della classe madre solamente se hanno lo stesso modello.

171 Introduzione al C++ Utilizzo di una classe madre ( Pacco ) Riepilogo: In questa discussione abbiamo visto che: 1.Un metodo pubblico può rendere accessibile all'esterno di una classe il valore di un'area privata. 2.Noto il puntatore, possiamo indirizzare aree e metodi di un oggetto con l'operatore -> 3.La parola riservata virtual dichiara che i metodi di una classe madre possono essere scavalcati dai metodi delle classi figlie. 4.Le classi madri sono appositamente costruite come modello per le classi figlie.

172 Introduzione al C++ Definizione di una classe figlia ( Latte )

173 Introduzione al C++ Definizione di una classe figlia ( Latte ) Get_Peso Get_Prezzo Pacco Get_Peso Miele itsPeso itsPrezzo Get_Prezzo Get_Peso Latte Get_Prezzo Il tipo di dato (definito dal programmatore) Latte è una specializzazione del tipo di dato (definito dal programmatore) Pacco.

174 Introduzione al C++ Definizione di una classe figlia ( Latte ) 1 #include "Pacco.h" 2 class Latte : public Pacco 3 { 4 public: 5 Latte (void); 6 ~Latte (void); 7 virtual int Get_Peso (void); 8 virtual int Get_Prezzo (void); 9 }; Questa è la definizione del tipo di dato (definito dal programmatore) Latte.

175 Introduzione al C++ Definizione di una classe figlia ( Latte ) 1 #include "Pacco.h" 2 class Latte : public Pacco 3 { 4 public: 5 Latte (void); 6 ~Latte (void); 7 virtual int Get_Peso (void); 8 virtual int Get_Prezzo (void); 9 }; Il tipo di dato (definito dal programmatore) Latte è una specializzazione del tipo di dato (definito dal programmatore) Pacco.

176 Introduzione al C++ Definizione di una classe figlia ( Latte ) 1 #include "Pacco.h" 2 class Latte : public Pacco 3 { 4 public: 5 Latte (void); 6 ~Latte (void); 7 virtual int Get_Peso (void); 8 virtual int Get_Prezzo (void); 9 }; La definizione del tipo di dato Latte inizia con la parola riservata class.

177 Introduzione al C++ Definizione di una classe figlia ( Latte ) 1 #include "Pacco.h" 2 class Latte : public Pacco 3 { 4 public: 5 Latte (void); 6 ~Latte (void); 7 virtual int Get_Peso (void); 8 virtual int Get_Prezzo (void); 9 }; Il nome del tipo di dato che stiamo definendo – Latte – segue la parola riservata class.

178 Introduzione al C++ Definizione di una classe figlia ( Latte ) 1 #include "Pacco.h" 2 class Latte : public Pacco 3 { 4 public: 5 Latte (void); 6 ~Latte (void); 7 virtual int Get_Peso (void); 8 virtual int Get_Prezzo (void); 9 }; L'operatore : indica che la classe Latte è una specializzazione di Pacco (ereditarietà).

179 Introduzione al C++ Definizione di una classe figlia ( Latte ) Riepilogo: In questa discussione abbiamo visto che: 1.Possiamo costruire una classe figlia Latte specializzazione della classe madre Pacco. 2.L'operatore : precede i nomi delle classi madri che specializziamo. 3.Le classi figlie contengono uno o più metodi che scavalcano quelli delle classi madri.

180 Introduzione al C++ Definizione di una classe figlia ( Miele )

181 Introduzione al C++ Definizione di una classe figlia ( Miele ) Get_Peso Get_Prezzo Pacco Get_Peso Miele itsPeso itsPrezzo Get_Prezzo Get_Peso Latte Get_Prezzo Il tipo di dato (definito dal programmatore) Miele è una specializzazione del tipo di dato (definito dal programmatore) Pacco.

182 Introduzione al C++ Definizione di una classe figlia ( Miele ) 1 #include "Miele.h" 2 class Miele : public Pacco 3 { 4 public: 5 Miele (void); 6 ~Miele (void); 7 virtual int Get_Peso (void); 8 virtual int Get_Prezzo (void); 9 }; Questa è la definizione del tipo di dato (definito dal programmatore) Miele.

183 Introduzione al C++ Definizione di una classe figlia ( Miele ) 1 #include "Miele.h" 2 class Miele : public Pacco 3 { 4 public: 5 Miele (void); 6 ~Miele (void); 7 virtual int Get_Peso (void); 8 virtual int Get_Prezzo (void); 9 }; In cosa differiscono le classi Latte e Miele ? Le classi Latte e Miele differiscono solamente nei nomi dei metodi di inizializzazione e di rilascio delle risorse. La somiglianza fra Latte e Miele non è casuale sono classi sorelle.

184 Introduzione al C++ Corpo di una classe figlia ( Latte )

185 Introduzione al C++ Corpo di una classe figlia ( Latte ) 1 int Latte:Get_Peso (void) 2 { 4 return 1; /* Un kg. */ 5 } Vi ricordate che il metodo Get_Peso della classe madre Pacco restituiva 0 (zero)? Ma quando richiamiamo il metodo Get_Peso della classe Latte ?

186 Introduzione al C++ Corpo di una classe figlia ( Miele )

187 Introduzione al C++ Corpo di una classe figlia ( Miele ) 1 int Miele:Get_Peso (void) 2 { 4 return 2; /* Due kg. */ 5 } Vi ricordate che il metodo Get_Peso della classe madre Pacco restituiva 0 (zero)? Ma quando richiamiamo il metodo Get_Peso della classe Miele ?

188 Introduzione al C++ Costruzione degli oggetti Latte e Miele

189 Introduzione al C++ Costruzione degli oggetti Latte e Miele 1 #include 2 #include "Carrello.h" 3 int main (int theArg_Qty, char **theArg_Ptr) 4 { 5 Carrello aCarrello1; 6 Pacco *aPacco1 = new Latte(); 7 Pacco *aPacco2 = new Miele(); 8 aCarrello1.Put_Pacco(aPacco1); 9 aCarrello1.Put_Pacco(aPacco2); 10 int aTot_Peso = aCarrello1.Get_Peso(); 11 printf ("Peso totale = %i\n", aTot_Peso); } Aggiungiamo alla funzione main la costruzione degli oggetti Latte e Miele.

190 Introduzione al C++ Costruzione degli oggetti Latte e Miele 1 #include 2 #include "Carrello.h" 3 int main (int theArg_Qty, char **theArg_Ptr) 4 { 5 Carrello aCarrello1; 6 Pacco *aPacco1 = new Latte(); 7 Pacco *aPacco2 = new Miele(); 8 aCarrello1.Put_Pacco(aPacco1); 9 aCarrello1.Put_Pacco(aPacco2); 10 int aTot_Peso = aCarrello1.Get_Peso(); 11 printf ("Peso totale = %i\n", aTot_Peso); } L'operatore new riserva dinamicamente lo spazio per le aree della classe Latte e ne richiama il metodo di inizializzazione.

191 Introduzione al C++ Costruzione degli oggetti Latte e Miele 1 Latte:::Latte (void) 2 : Pacco() 3 { } Il metodo di inizializzazione della classe figlia Latte richiama il metodo di inizializzazione della classe madre Pacco...

192 Introduzione al C++ Costruzione degli oggetti Latte e Miele 1 Latte:::Latte (void) 2 : Pacco() 3 { } …e poi inizializza le sue aree private che specializzano la classe madre Pacco.

193 Introduzione al C++ Costruzione degli oggetti Latte e Miele 1 #include 2 #include "Carrello.h" 3 int main (int theArg_Qty, char **theArg_Ptr) 4 { 5 Carrello aCarrello1; 6 Pacco *aPacco1 = new Latte(); 7 Pacco *aPacco2 = new Miele(); 8 aCarrello1.Put_Pacco(aPacco1); 9 aCarrello1.Put_Pacco(aPacco2); 10 int aTot_Peso = aCarrello1.Get_Peso(); 11 printf ("Peso totale = %i\n", aTot_Peso); } L'operatore new valorizza l'area aPacco1 con un puntatore al nuovo oggetto Latte.

194 Introduzione al C++ Costruzione degli oggetti Latte e Miele 1 #include 2 #include "Carrello.h" 3 int main (int theArg_Qty, char **theArg_Ptr) 4 { 5 Carrello aCarrello1; 6 Pacco *aPacco1 = new Latte(); 7 Pacco *aPacco2 = new Miele(); 8 aCarrello1.Put_Pacco(aPacco1); 9 aCarrello1.Put_Pacco(aPacco2); 10 int aTot_Peso = aCarrello1.Get_Peso(); 11 printf ("Peso totale = %i\n", aTot_Peso); } Il puntatore ad un oggetto di tipo Latte può valorizzare un puntatore ad un oggetto di tipo Pacco poiché Latte è una specializzazione di Pacco.

195 Introduzione al C++ Costruzione degli oggetti Latte e Miele 1 #include "Pacco.h" 2 class Latte : public Pacco 3 { 4 public: 5 Latte (void); 6 ~Latte (void); 7 virtual int Get_Peso (void); 8 virtual int Get_Prezzo (void); 9 }; È la classe Latte che dichiara nel suo modello che è una figlia della classe Pacco.

196 Introduzione al C++ Costruzione degli oggetti Latte e Miele 1 #include 2 #include "Carrello.h" 3 int main (int theArg_Qty, char **theArg_Ptr) 4 { 5 Carrello aCarrello1; 6 Pacco *aPacco1 = new Latte(); 7 Pacco *aPacco2 = new Miele(); 8 aCarrello1.Put_Pacco(aPacco1); 9 aCarrello1.Put_Pacco(aPacco2); 10 int aTot_Peso = aCarrello1.Get_Peso(); 11 printf ("Peso totale = %i\n", aTot_Peso); } Questo rende possibile valorizzare l'area aPacco1 di tipo Pacco * con un puntatore ad un oggetto di tipo Latte.

197 Introduzione al C++ Costruzione degli oggetti Latte e Miele 1 #include 2 #include "Carrello.h" 3 int main (int theArg_Qty, char **theArg_Ptr) 4 { 5 Carrello aCarrello1; 6 Pacco *aPacco1 = new Latte(); 7 Pacco *aPacco2 = new Miele(); 8 aCarrello1.Put_Pacco(aPacco1); 9 aCarrello1.Put_Pacco(aPacco2); 10 int aTot_Peso = aCarrello1.Get_Peso(); 11 printf ("Peso totale = %i\n", aTot_Peso); } L'operatore new riserva dinamicamente lo spazio per le aree della classe Miele e ne richiama il metodo di inizializzazione.

198 Introduzione al C++ Costruzione degli oggetti Latte e Miele 1 Miele:::Miele (void) 2 : Pacco() 3 { } Il metodo di inizializzazione della classe figlia Miele richiama il metodo di inizializzazione della classe madre Pacco...

199 Introduzione al C++ Costruzione degli oggetti Latte e Miele 1 Miele:::Miele (void) 2 : Pacco() 3 { } …e poi inizializza le sue aree private che specializzano la classe madre Pacco.

200 Introduzione al C++ Costruzione degli oggetti Latte e Miele 1 #include 2 #include "Carrello.h" 3 int main (int theArg_Qty, char **theArg_Ptr) 4 { 5 Carrello aCarrello1; 6 Pacco *aPacco1 = new Latte(); 7 Pacco *aPacco2 = new Miele(); 8 aCarrello1.Put_Pacco(aPacco1); 9 aCarrello1.Put_Pacco(aPacco2); 10 int aTot_Peso = aCarrello1.Get_Peso(); 11 printf ("Peso totale = %i\n", aTot_Peso); } L'operatore new valorizza l'area aPacco2 con un puntatore al nuovo oggetto Miele.

201 Introduzione al C++ Costruzione degli oggetti Latte e Miele 1 #include 2 #include "Carrello.h" 3 int main (int theArg_Qty, char **theArg_Ptr) 4 { 5 Carrello aCarrello1; 6 Pacco *aPacco1 = new Latte(); 7 Pacco *aPacco2 = new Miele(); 8 aCarrello1.Put_Pacco(aPacco1); 9 aCarrello1.Put_Pacco(aPacco2); 10 int aTot_Peso = aCarrello1.Get_Peso(); 11 printf ("Peso totale = %i\n", aTot_Peso); } Il puntatore ad un oggetto di tipo Miele può valorizzare un puntatore ad un oggetto di tipo Pacco poiché Miele è una specializzazione di Pacco.

202 Introduzione al C++ Costruzione degli oggetti Latte e Miele 1 #include "Pacco.h" 2 class Miele : public Pacco 3 { 4 public: 5 Miele (void); 6 ~Miele (void); 7 virtual int Get_Peso (void); 8 virtual int Get_Prezzo (void); 9 }; È la classe Miele che dichiara nel suo modello che è una figlia della classe Pacco.

203 Introduzione al C++ Costruzione degli oggetti Latte e Miele 1 #include 2 #include "Carrello.h" 3 int main (int theArg_Qty, char **theArg_Ptr) 4 { 5 Carrello aCarrello1; 6 Pacco *aPacco1 = new Latte(); 7 Pacco *aPacco2 = new Miele(); 8 aCarrello1.Put_Pacco(aPacco1); 9 aCarrello1.Put_Pacco(aPacco2); 10 int aTot_Peso = aCarrello1.Get_Peso(); 11 printf ("Peso totale = %i\n", aTot_Peso); } Questo rende possibile valorizzare l'area aPacco2 di tipo Pacco * con un puntatore ad un oggetto di tipo Miele.

204 Introduzione al C++ Costruzione degli oggetti Latte e Miele 1 #include 2 #include "Carrello.h" 3 int main (int theArg_Qty, char **theArg_Ptr) 4 { 5 Carrello aCarrello1; 6 Pacco *aPacco1 = new Latte(); 7 Pacco *aPacco2 = new Miele(); 8 aCarrello1.Put_Pacco(aPacco1); 9 aCarrello1.Put_Pacco(aPacco2); 10 int aTot_Peso = aCarrello1.Get_Peso(); 11 printf ("Peso totale = %i\n", aTot_Peso); } Il metodo Put_Pacco memorizza un puntatore ad un oggetto di tipo Pacco nell'oggetto aCarrello1.

205 Introduzione al C++ Costruzione degli oggetti Latte e Miele 1 #include 2 #include "Carrello.h" 3 int main (int theArg_Qty, char **theArg_Ptr) 4 { 5 Carrello aCarrello1; 6 Pacco *aPacco1 = new Latte(); 7 Pacco *aPacco2 = new Miele(); 8 aCarrello1.Put_Pacco(aPacco1); 9 aCarrello1.Put_Pacco(aPacco2); 10 int aTot_Peso = aCarrello1.Get_Peso(); 11 printf ("Peso totale = %i\n", aTot_Peso); } Prima viene memorizzato il puntatore aPacco1 all'oggetto di tipo Latte...

206 Introduzione al C++ Costruzione degli oggetti Latte e Miele 1 #include 2 #include "Carrello.h" 3 int main (int theArg_Qty, char **theArg_Ptr) 4 { 5 Carrello aCarrello1; 6 Pacco *aPacco1 = new Latte(); 7 Pacco *aPacco2 = new Miele(); 8 aCarrello1.Put_Pacco(aPacco1); 9 aCarrello1.Put_Pacco(aPacco2); 10 int aTot_Peso = aCarrello1.Get_Peso(); 11 printf ("Peso totale = %i\n", aTot_Peso); } …e poi viene memorizzato il puntatore aPacco2 all'oggetto di tipo Miele.

207 Introduzione al C++ Costruzione degli oggetti Latte e Miele 1 void Carrello::Put_Pacco (Pacco *thePacco_Ptr) 2 { 3 int aSpesa_Max 4 = (sizeof itsSpesa / sizeof itsSpesa[0]); 5 if ((thePacco_Ptr) 6 && (itsSpesa_Qty < aSpesa_Max)) 7 { 8 itsSpesa[itsSpesa_Qty++] = thePacco_Ptr; 9 } 10 } Esaminiamo più indettaglio il corpo del metodo Get_Pacco.

208 Introduzione al C++ Costruzione degli oggetti Latte e Miele 1 void Carrello::Put_Pacco (Pacco *thePacco_Ptr) 2 { 3 int aSpesa_Max 4 = (sizeof itsSpesa / sizeof itsSpesa[0]); 5 if ((thePacco_Ptr) 6 && (itsSpesa_Qty < aSpesa_Max)) 7 { 8 itsSpesa[itsSpesa_Qty++] = thePacco_Ptr; 9 } 10 } Questo è il metodo Put_Pacco...

209 Introduzione al C++ Costruzione degli oggetti Latte e Miele 1 void Carrello::Put_Pacco (Pacco *thePacco_Ptr) 2 { 3 int aSpesa_Max 4 = (sizeof itsSpesa / sizeof itsSpesa[0]); 5 if ((thePacco_Ptr) 6 && (itsSpesa_Qty < aSpesa_Max)) 7 { 8 itsSpesa[itsSpesa_Qty++] = thePacco_Ptr; 9 } 10 } …che appartiene alla classe Carrello...

210 Introduzione al C++ Costruzione degli oggetti Latte e Miele 1 void Carrello::Put_Pacco (Pacco *thePacco_Ptr) 2 { 3 int aSpesa_Max 4 = (sizeof itsSpesa / sizeof itsSpesa[0]); 5 if ((thePacco_Ptr) 6 && (itsSpesa_Qty < aSpesa_Max)) 7 { 8 itsSpesa[itsSpesa_Qty++] = thePacco_Ptr; 9 } 10 } …riceve in entrata un puntatore thePacco_Ptr ad un oggetto di tipo Pacco.

211 Introduzione al C++ Costruzione degli oggetti Latte e Miele 1 void Carrello::Put_Pacco (Pacco *thePacco_Ptr) 2 { 3 int aSpesa_Max 4 = (sizeof itsSpesa / sizeof itsSpesa[0]); 5 if ((thePacco_Ptr) 6 && (itsSpesa_Qty < aSpesa_Max)) 7 { 8 itsSpesa[itsSpesa_Qty++] = thePacco_Ptr; 9 } 10 } Il metodo calcola la quantità aSpesa_Max di elementi nel vettore itsSpesa dividendo la lunghezza dell'intero vettore per quella di un elemento qualsiasi.

212 Introduzione al C++ Costruzione degli oggetti Latte e Miele 1 void Carrello::Put_Pacco (Pacco *thePacco_Ptr) 2 { 3 int aSpesa_Max 4 = (sizeof itsSpesa / sizeof itsSpesa[0]); 5 if ((thePacco_Ptr) 6 && (itsSpesa_Qty < aSpesa_Max)) 7 { 8 itsSpesa[itsSpesa_Qty++] = thePacco_Ptr; 9 } 10 } Il metodo verifica di avere ricevuto un puntatore diverso da 0 (zero)...

213 Introduzione al C++ Costruzione degli oggetti Latte e Miele 1 void Carrello::Put_Pacco (Pacco *thePacco_Ptr) 2 { 3 int aSpesa_Max 4 = (sizeof itsSpesa / sizeof itsSpesa[0]); 5 if ((thePacco_Ptr) 6 && (itsSpesa_Qty < aSpesa_Max)) 7 { 8 itsSpesa[itsSpesa_Qty++] = thePacco_Ptr; 9 } 10 } …e allo stesso tempo di non avere oltrepassato la quantità massima di elementi validi nel vettore istSpesa.

214 Introduzione al C++ Costruzione degli oggetti Latte e Miele 1 void Carrello::Put_Pacco (Pacco *thePacco_Ptr) 2 { 3 int aSpesa_Max 4 = (sizeof itsSpesa / sizeof itsSpesa[0]); 5 if ((thePacco_Ptr) 6 && (itsSpesa_Qty < aSpesa_Max)) 7 { 8 itsSpesa[itsSpesa_Qty++] = thePacco_Ptr; 9 } 10 } Il puntatore in argomento thePacco_Prt è assegnato all'elemento corrente del vettore itsSpesa itsSpesa[itsSpesa_Qty].

215 Introduzione al C++ Costruzione degli oggetti Latte e Miele 1 void Carrello::Put_Pacco (Pacco *thePacco_Ptr) 2 { 3 int aSpesa_Max 4 = (sizeof itsSpesa / sizeof itsSpesa[0]); 5 if ((thePacco_Ptr) 6 && (itsSpesa_Qty < aSpesa_Max)) 7 { 8 itsSpesa[itsSpesa_Qty++] = thePacco_Ptr; 9 } 10 } L'indice itsSpesa_Qty viene incrementato solamente dopo avere assegnato il puntatore all'elemento corrente del vettore itsSpesa.

216 Introduzione al C++ Costruzione degli oggetti Latte e Miele 1 #include 2 #include "Carrello.h" 3 int main (int theArg_Qty, char **theArg_Ptr) 4 { 5 Carrello aCarrello1; 6 Pacco *aPacco1 = new Latte(); 7 Pacco *aPacco2 = new Miele(); 8 aCarrello1.Put_Pacco(aPacco1); 9 aCarrello1.Put_Pacco(aPacco2); 10 int aTot_Peso = aCarrello1.Get_Peso(); 11 printf ("Peso totale = %i\n", aTot_Peso); } Dopo avere memorizzato i puntatori aPacco1 e aPacco2 nell'oggetto aCarrello1, è possibile calcolare il peso totale della spesa col metodo Get_Peso della classe Carrello.

217 Introduzione al C++ Costruzione degli oggetti Latte e Miele 1 int Carrello::Get_Peso (void) 2 { 3 int aTot_Peso = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 8 if (!itsSpesa[tIndex]) break; 9 aTot_Peso += itsSpesa[tIndex]->Get_Peso(); 10 } 11 return aTot_Peso; 12 } Il metodo Get_Peso della classe Carrello richiama il metodo Get_Peso della classe Pacco tramite un puntatore. Ma dove è il metodo Get_Peso ?

218 Introduzione al C++ Costruzione degli oggetti Latte e Miele 1 int Carrello::Get_Peso (void) 2 { 3 int aTot_Peso = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 8 if (!itsSpesa[tIndex]) break; 9 aTot_Peso += itsSpesa[tIndex]->Get_Peso(); 10 } 11 return aTot_Peso; 12 } Il metodo Get_Peso della classe Pacco al primo ciclo è nella classe Latte e al secondo ciclo è nella classe Miele. Perché?

219 Introduzione al C++ Costruzione degli oggetti Latte e Miele 1 #include 2 #include "Carrello.h" 3 int main (int theArg_Qty, char **theArg_Ptr) 4 { 5 Carrello aCarrello1; 6 Pacco *aPacco1 = new Latte(); 7 Pacco *aPacco2 = new Miele(); 8 aCarrello1.Put_Pacco(aPacco1); 9 aCarrello1.Put_Pacco(aPacco2); 10 int aTot_Peso = aCarrello1.Get_Peso(); 11 printf ("Peso totale = %i\n", aTot_Peso); } Perché prima abbiamo costruito un oggetto di tipo Latte con l'operatore new, e lo abbiamo memorizzato nella prima posizione nell'oggetto aCarrello1...

220 Introduzione al C++ Costruzione degli oggetti Latte e Miele 1 #include 2 #include "Carrello.h" 3 int main (int theArg_Qty, char **theArg_Ptr) 4 { 5 Carrello aCarrello1; 6 Pacco *aPacco1 = new Latte(); 7 Pacco *aPacco2 = new Miele(); 8 aCarrello1.Put_Pacco(aPacco1); 9 aCarrello1.Put_Pacco(aPacco2); 10 int aTot_Peso = aCarrello1.Get_Peso(); 11 printf ("Peso totale = %i\n", aTot_Peso); } …e poi abbiamo costruito un oggetto di tipo Miele con l'operatore new, e lo abbiamo memorizzato nella seconda posizione nell'oggetto aCarrello1.

221 Introduzione al C++ Costruzione degli oggetti Latte e Miele 1 int Carrello::Get_Peso (void) 2 { 3 int aTot_Peso = 0; 4 for (int tIndex = 0; 5 tIndex < (sizeof itsSpesa / itsSpesa[0]); 6 ++tIndex) 7 { 8 if (!itsSpesa[tIndex]) break; 9 aTot_Peso += itsSpesa[tIndex]->Get_Peso(); 10 } 11 return aTot_Peso; 12 } Questa tecnica di richiamare metodi scavalcabili definiti nelle classi figlie mediante un puntatore alla classe madre è detta polimorfismo.

222 Introduzione al C++ Introduzione al linguaggio C++ 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


Scaricare ppt "Introduzione al C++ Introduzione al linguaggio C++"

Presentazioni simili


Annunci Google