Introduzione al C++ Introduzione al linguaggio C++

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.

Introduzione al C++ Modello della funzione principale ( Unix )

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

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

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

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.

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

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

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

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.

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

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

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

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.

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

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.

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

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.

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

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.

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

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

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

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

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.

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 ?

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?

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.

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

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

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

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

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

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.

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.

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.

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.

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.

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.

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.

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.

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

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?

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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 ?

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.

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.

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 ?

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

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.

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.

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.

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.

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.

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.

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)?

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

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

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.

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

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.

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.

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

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

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.

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.

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.

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.

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.

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

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

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

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.

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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:

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

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

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.

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.

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.

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.

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.

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.

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

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

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

Introduzione al C++ Stampa di un valore

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.

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

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.

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.

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.

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.

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.

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.

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

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

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.

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.

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

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

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

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

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

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.

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

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.

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.

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

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

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

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

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

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

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

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.

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.

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.

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

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.

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 ?

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

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

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();

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.

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 ?

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.

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.

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.

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

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

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.

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

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.

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

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

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.

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?

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.

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.

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.

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.

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

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.

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.

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.

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.

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.

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

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.

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

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.

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.

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.

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

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 ?

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

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 ?

Introduzione al C++ Costruzione degli oggetti Latte e Miele

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.

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.

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

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.

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.

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.

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.

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.

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.

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

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.

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.

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.

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.

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.

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.

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

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.

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.

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

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

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.

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.

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

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.

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

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.

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.

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 ?

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é?

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

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.

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.

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