Skillbook Logo
foto profilo

Skill Factory

Categoria: Tutorials


Introduzione alla logica degli oggetti - Lezione 6

Gino Visciano | Skill Factory - 09/12/2018 13:36:37 | in Tutorials

In questa lezione parliamo di Contenitori anche detti Collezioni, classi specializzate per la gestione di raccolte di oggetti con modalità di accesso differenti.

Le Collezioni possono essere di 4 tipi:

vediamo in dettaglio le loro caratteristiche.

LE LISTE
Le Liste sono contenitori di oggetti simili ai vettori,  di dimensioni dinamiche e modalità di accesso indicizzata, questo significa che in una lista potete aggiungere tutti i valori oppure gli oggetti che volete ed ognuno di essi può essere identificato da un valore numerico chiamato indice, come per i vettori, il primo indice corrisponde al valore 0.

L'immagine seguente mostra la struttura di una lista, che contiene i riferimenti di tre oggetti di tipo Persona:

 

Attenzione persona1, persona2 e persona3 corrispondono agli indirizzi di memoria (riferimenti) delle posizioni dove sono stati istanziati i tre oggeti di tipo Persona.

In C++ per  inserire valori oppure oggetti all'inizio di una lista, si usa il metodo push_front(), per inserirli alla fine, si usa il metodo push_back(), mentre per puntare al primo oppure all'ultimo elemento si usano i metodi pop_front() e pop_back().  Per leggere ed eliminare il primo oppure l'ultimo elemento di una lista si usano i metodi front() e back().

L'immagine seguente mostra come si gestisce una lista in C++.

Per conoscere quanti elementi sono presenti in una lista, potete usare il metodo size(), altri metodi importatnti sono:

empty() restituisce true se la lista è vuota false se contiene elementi;
clear() elimina tutti gli elementi di una lista;
erase(posizione) oppure erese(da,a) elimina dalla lista uno specifico elemento oppure un intervallo di elementi;
insert(posizione,valore) inserisce il valore prima della posizione indicata.

Per passare alla partica, vediamo un esempio, scritto in linguaggio C++,

Esempio 1

// Calcola il totale dei valori interi inseriti nella lista
#include <iostream>
#include <list>
using namespace std;

int main ()
{
// Dichiarazione lista che contiene valori interi. Valori è il riferimento che contiene l'indirizzo di dove è stata allocata la lista
list<int> valori;
int somma=0;
// Inserimento alla fine della lista di valori interi
valori.push_back (10);
valori.push_back (20);
valori.push_back (30);
// Mentre la lista è piena, viene letto l'ultimo valore ed aggiunto alla variabile somma. Successivamente il valore letto viene rimosso. Alla fine del ciclo la lista sarà vuota
while (!valori.empty())
  {

    // Legge l'ultimo valore della lista e allo stesso tempo lo elimina. Il metodo back() legge ed elimina.
    // Per leggere senza eliminare il valore dovete usare un iteratore

    somma+=valori.back();
   // Punta all'ultimo elemento disponibile nella lista
    valori.pop_back();
  }
// Visualizza il Totale contenuto nella variabile somma e va a capo (endl='\n')
  cout << "Totale:" << somma << endl;
  return 0;
}

 

Per ordinare una lista in C++, si usa il metodo sort(),  al metodo potete anche passare un metodo in cui vengono indicate le modalità di comparazione da usare per l'ordinamento.

Gli esempi seguenti mostrano come ordinare una lista di numeri interi, sia in modo crescente, sia in modo decrescente.

Esempio 2

// Lista ordinata in modo crescente
#include <iostream>
#include <list>

using namespace std;

int main(){
    list<int> valori;
    valori.push_back(50);
    valori.push_back(40);
    valori.push_back(30);
    valori.push_back(10);
    valori.push_back(20);
    valori.push_back(35);
    valori.push_back(60);
    valori.push_back(45);
    valori.push_back(23);
    valori.push_back(15);
    // Ordina la lista in modo crescente
    valori.sort();
    while (!valori.empty())
    {
         // Legge il primo valore della lista e allo stesso tempo lo elimina. Il metodo front() legge ed elimina.
         // Per leggere senza eliminare il valore dovete usare un iteratore

        cout << valori.front() << endl;
       // Punta al primo elemento disponibile nella lista
        valori.pop_front();
    }
      return 0;
}



Esempio 3

// Lista ordinata in modo decrescente
#include <iostream>
#include <list>

using namespace std;

int main(){
    list<int> valori;
    valori.push_back(50);
    valori.push_back(40);
    valori.push_back(30);
    valori.push_back(10);
    valori.push_back(20);
    valori.push_back(35);
    valori.push_back(60);
    valori.push_back(45);
    valori.push_back(23);
    valori.push_back(15);
    // Ordina la lista in modo decrescente, il metodo greater<int>() permette d'indicare il metdo di comparazione decrescente
    valori.sort(greater<int>());
    while (!valori.empty())
    {
         // Legge il primo valore della lista e allo stesso tempo lo elimina. Il metodo front() legge ed elimina.
         // Per leggere senza eliminare il valore dovete usare un iteratore

        cout << valori.front() << endl;
        valori.pop_front();
    }
      return 0;

}

Come avete potuto notare dagli esempi precedenti, in C++, ogni volta che si usano i metodi back() e front(), per leggere un valore dalla lista, il valore viene eliminato, questo significa che se leggete tutti i valori, alla fine la lista sarà vuota.  Per evitare di svuotare le liste dopo la lettura dei valori, usare un iteratore, un riferimento dinamico che può essere incrementato oppure decrementato, che permette di puntare ad un elemento qualsiasi della lista. Dopo aver creato l'iteratore, per ottenere il riferimento del primo elemento di una lista si usa il metodo begin(), mentre il metodo end() restituisce l'indirizzo che corrisponde alla fine della lista.

L'immagine seguente mostra il funzionamento degli iteratori in C++:

 

I due esempi seguenti mostrano come si usano gli iteratori per visualizzare i valori di una lista con C++:

Esempio 4

#include <iostream>
#include <list>

using namespace std;

int main ()
{
  // Vettore con i valori da inserire nella lista
  int vlista[]= {10,30,20,30,5};
  // Creo una lista passando al costruttore i valori del vettore vlista
  // L'argomento vlista è l'indirizzo del primo valore, vlista+4 è l'indirizzo dell'ultimo valore - lista (da,a)

  list<int> lista (vlista,vlista+4);
  list<int>::iterator iterLista;
  // Assegno all'iteratore l'indirizzo del primo valore della lista
  iterLista=lista.begin();
  cout << "Elenco valori nella lista:" << endl;
  // Il ciclo serve per incrementare per 5 volte l'indirizzo memorizzato nell'iteratore e visualizzare il contenuto della lista
  for(int x=0;x<lista.size();x++){
    // *iterLista visualizza il valore corrispondente all'indirizzo memorizzato nell'iteratore
    // successivamente ++ incrementa l'indirizzo corrente di una posizione per puntare la valore seguente

    cout << *iterLista++ << endl;
  }
  // Rimuove tutti i valori 30 dalla lista
  lista.remove(30);
  cout << "Elenco valori nella lista dopo la cancellazione:" << endl;
  // Visualizza tutti i valori della lista usando l'iteratore
  for (iterLista=lista.begin(); iterLista!=lista.end(); ++iterLista) {
    cout << *iterLista << endl;
    }
  return 0;
}

 

 

Esempio 5

// Lista di nomi ordinata in modo crescente
#include <iostream>
#include <list>
#include <string>
#include <cctype>

using namespace std;

// compara i nomi della lista trascurando la differenza tra maiuscolo e minuscolo (not case sensitive)
bool compara_nocase (const string& prima, const string& seconda)
{
  unsigned int i=0;
// Il ciclo continua ad essere eseguito mentre il valore della variabile è minore della lunghezza del primo nome e del secondo nome
  while ( (i<prima.length()) && (i<seconda.length()) )
  {
    // Se il carattere iesimo del primo nome e minore del carattere iesimo del secondo nome viene restituito true altrimenti false
    if (tolower(prima[i])<tolower(seconda[i])) return true;
    else if (tolower(prima[i])>tolower(seconda[i])) return false;
    ++i;
  }
  return ( prima.length() < seconda.length() );
}

int main ()
{
  int i;
  list<string> nomi;
  list<string>::iterator iterNomi;
  nomi.push_back ("Mario");
  nomi.push_back ("Alessandra");
  nomi.push_back ("Carlo");
  nomi.push_back ("mario");
  nomi.push_back ("ALESSANDRA");
  nomi.push_back ("carlo");
  nomi.push_back ("Marianna");
  nomi.push_back ("ROBERTA");
  nomi.push_back ("ROBERTO");
  nomi.sort();
  i=0;
  cout << "Elenco nomi ordinati considerando la differenza tra maiuscolo e minuscolo:"  << endl;
  for (iterNomi=nomi.begin(); iterNomi!=nomi.end(); ++iterNomi)
    cout << ++i << ' ' << *iterNomi << endl;
  cout << endl;
  nomi.sort(compara_nocase);
  i=0;
  cout << "Elenco nomi ordinati senza considerare la differenza tra maiuscolo e minuscolo:" << endl;
  for (iterNomi=nomi.begin(); iterNomi!=nomi.end(); ++iterNomi)
    cout << ++i << ' ' << *iterNomi  << endl;
  cout << endl;

  return 0;
}


 

COME INSERIRE OGGETTI IN UNA LISTA

L'esempio seguente mostra come si gestisce una lista di oggetti di tipo Persona con C++.

Esempio 6

 

LE MAPPE
Le Mappe sono contenitori che permettono di associare un valore oppure un oggetto ad una chiave. In pratica è come indirizzare un vettore con una valore qualsiasi invece che con un indice numerico.
Anche le Mappe sono contenitori di dimensioni dinamiche e modalità di accesso indicizzata.

L'immagine seguente mostra la struttura di una mappa che contiene i riferimenti di oggetti di tipo Persona:

 

In C++ per aggiungere un valore ad una  mappa potete usare i comandi seguenti:

1) mappa["dieci"]=10;

oppure

2) mappa.insert(pair<string,int>("dieci", 10));

In entrambi i casi la chiave scelta, "dieci", è di tipo stringa, mentre il valore associato, 10, è di tipo intero.

Attenzione le chiavi associate ai valori oppure agli oggetti di una mappa possono essere di qualunque tipo, nell'esempio sono chiavi di tipo stringa.

Il metodo insert(...) permette d'inserire in una mappa la struttura pair che corrisponde ad una tupla con due campi first (chiave) e second (valore):

mappa->first corrisponde alla chiave di tipo stringa "dieci";

mappa->second corrisponde al valore di tipo intero 10;

Vediamo tre esempi sviluppati con C++:

Esempio 7

#include <iostream>
#include <string>
#include <map>

using namespace std;

int main ()
{
map<string,int> mappa;
// Inserimento valori interi nella mappa
mappa["primo"] = 1;
mappa["secondo"] = 2;
mappa["terzo"] = 3;
mappa["quarto"] = 4;
mappa["quinto"] = 5;
// Visualizzazione valori attraverso l'uso delle chiavi associate ai valori
cout << "1) Accesso diretto attraverso la chiave:" << endl;
cout << mappa["primo"] << endl;
cout << mappa["secondo"] << endl;
cout << mappa["terzo"] << endl;
cout << mappa["quarto"] << endl;
cout << mappa["quinto"] << endl;
// Dichiarazione iteratore
map<string,int>::iterator iteraMappa;
cout << "2) Accesso attraverso un iteratore:" << endl;
// Visualizzazione valori attraverso l'uso dell'iteratore
for (iteraMappa=mappa.begin();iteraMappa!=mappa.end();++iteraMappa) {
    cout << iteraMappa->first << ": " << iteraMappa->second << endl;
  }

  return 0;
}


Come potete vedere l'iteratore ordina le chiavi in modo crescete.

Esempio 8

#include <iostream>
#include <string>
#include <map>

using namespace std;

int main ()
{
map<string,int> mappa;
map<string,int>::iterator iteraMappa;
// Inserimento valori attraverso l'uso di una tupla di tipo pair
mappa.insert(pair<string,int>("primo", 0));
mappa.insert(pair<string,int>("secondo", 0));
mappa.insert(pair<string,int>("terzo", 0 ) );
mappa.insert(pair<string,int>("quarto",0));
mappa.insert(pair<string,int>("quinto",0));
// Il metodo at(chiave) permette di modificare il valore associato alla chiave
mappa.at("primo") = 1;
mappa.at("secondo") = 2;
mappa.at("terzo") = 3;
mappa.at("quarto") = 4;
mappa.at("quinto") = 5;
// Visualizzazione valori attraverso l'uso dell'iteratore
cout << "Accesso attraverso un iteratore:" << endl;
for (iteraMappa=mappa.begin();iteraMappa!=mappa.end();++iteraMappa) {
    cout << iteraMappa->first << ": " << iteraMappa->second << endl;
  }

  return 0;
}

 

Esempio 9

#include <iostream>
#include <string>
#include <map>

using namespace std;

int main ()
{
map<string,int> mappa;
// Inserimento valori interi nella mappa
mappa["primo"] = 1;
mappa["secondo"] = 2;
mappa["terzo"] = 3;
mappa["quarto"] = 4;
mappa["quinto"] = 5;
// Dichiarazione iteratore
map<string,int>::iterator iteraMappa;
// Visualizzazione valori attraverso l'uso dell'iteratore
cout << "2) Accesso attraverso un iteratore:" << endl;
for (iteraMappa=mappa.begin();iteraMappa!=mappa.end();++iteraMappa) {
    cout << iteraMappa->first << ": " << iteraMappa->second << endl;
  }
// Il metodo find cerca nella mappa la chiave fornita come argomento ed assegna all'iteratore l'indirizzo corrispondente alla posizione della chiave cercata
iteraMappa=mappa.find("secondo");
// Il metodo erase cancella l'elemento all'indirizzo memorizzato nell'iteratore
mappa.erase(iteraMappa);
iteraMappa=mappa.find("quarto");
mappa.erase(iteraMappa);
cout << "2) Elenco valori dopo cancellazione:" << endl;
for (iteraMappa=mappa.begin();iteraMappa!=mappa.end();++iteraMappa) {
    cout << iteraMappa->first << ": " << iteraMappa->second << endl;
  }

  return 0;
}

 

COME INSERIRE OGGETTI IN UNA MAPPA

In una  mappa si possono anche inserire oggetti, l'esempio seguente mostra come si gestisce una mappa di oggetti di tipo Persona con C++:

Esempio 10


GLI INSIEMI
Gli Insiemi sono contenitori di valori oppure di oggetti distinti (detti anche componenti o membri) dello stesso tipo. A differenza delle liste e delle mappe gli elementi di un insieme non possono essere duplicati, cioè un insieme non può contenere valori uguali oppure oggetti con lo stesso contenuto.

Il numero di elementi di un insieme è detto cardinalità.

I due esempi seguenti mostrano come si gestisce un insieme di numeri interi , con C++:

Esempio 11

int main(){
    // Dichiarazione di un insieme di numeri interi
    set<int> valori;
    // Dichiarazione di un iteratore
    set<int>::iterator iterValori;
   // Inserimento valori interi nell'insieme
    valori.insert(50);
    valori.insert(40);
    valori.insert(30);
    valori.insert(10);
    valori.insert(20);
    valori.insert(30);
    valori.insert(50);
    valori.insert(40);
    valori.insert(20);
    valori.insert(10);
   // Visualizzazione cardinalità e contenuto dell'insieme attraverso l'uso di un iteratore
    cout << "Cardinalita':" << valori.size() << endl << endl;
    for (iterValori=valori.begin(); iterValori!=valori.end(); ++iterValori){
         cout << *iterValori << endl;
    }
    return 0;
}

 

Esempio 12

#include <iostream>
#include <set>

using namespace std;

int main(){
    set<int> valori;
    // Dichiarazione di un iteratore
    set<int>::iterator iterValori;
   // Inserimento valori interi nell'insieme
    valori.insert(50);
    valori.insert(40);
    valori.insert(30);
    valori.insert(10);
    valori.insert(20);
    valori.insert(30);
    valori.insert(50);
    valori.insert(40);
    valori.insert(20);
    valori.insert(10);
   // Visualizza la cardinalità ed il contenuto dell'insieme attraverso l'uso di un iteratore
    cout << "Cardinalita':" << valori.size() << endl;
    for (iterValori=valori.begin(); iterValori!=valori.end(); ++iterValori){
         cout << *iterValori << endl;
    }
    // Il mtodo find cerca il valore fornito come argomento ed assegna all'iteratore l'indirizzo della posizione nell'insieme
    iterValori=valori.find(20);
   // Il metodo erase utilizza la posizione memorizzata nell'iteratore per eliminare l'elemento corrispondente
    valori.erase(iterValori);
    iterValori=valori.find(40);
    valori.erase(iterValori);
   // Visualizzaza la cardinalità ed il contenuto dell'insieme attraverso l'uso di un iteratore dopo l'eliminazione dei due elementi
    cout << "Cardinalita' dopo la cancellazione dei valori:" << valori.size() << endl;
    for (iterValori=valori.begin(); iterValori!=valori.end(); ++iterValori){
         cout << *iterValori << endl;
    }
    return 0;
}

COME INSERIRE OGGETTI IN UN INSIEME

Se in un insieme  vengono inseriti oggetti, dovete sovrascrivere l'operatore <, come mostra l'esempio seguente:

bool operator<(const Persona& x) const {
    string strPersona1, strPersona2;
    bool esito=false;
    stringstream seta1;
    stringstream seta2;
    seta1 << eta;
    seta2 << x.eta;
    strPersona1=cognome+nome+seta1.str();
    strPersona2=x.cognome+x.nome+seta2.str();
    return strPersona1<strPersona2;
 }

Il programma seguente mostra come si gestisce un insieme di oggetti di tipo Persona, con C++:

Esempio 13

 

 

LE CODE
Le Code sono pile sequenziali di valori oppure oggetti di tipo FIFO (First In First Out - Il primo ad entrare è il primo ad uscire) oppure di tipo LIFO (Last In First Out - L'ultimo ad entrare è il primo ad uscire).

L'immagine seguente mostra il comportamento di una coda di tipo FIFO (Queue) :

 

Gli elementi di una coda di tipo FIFO (Queue) si comportano come le persone che fanno la fila ad una cassa.

L'immagine seguente mostra il comportamento di una coda di tipo LIFO (Stack):

 

Gli elementi di una coda di tipo LIFO (Stack) si comportano come una pila di piatti.

In C++, per aggiungere un valore oppure un oggetto ad una coda si usa il metodo push(), per puntare al successivo elemento si usa il metodo pop(), per estrarlo da una coda, si usa il metodo front(), per estrarlo da uno stack, si usa il metodo top(),come mostrano gli esempi seguenti:

Esempio 14

#include <iostream>
#include <queue>

using namespace std;

int main()
{
  // Dichiarazione coda di valori interi di tipo FIFO
  queue <int> coda;
 // Inserimento valori nella coda
  coda.push(10);
  coda.push(20);
  coda.push(30);
  coda.push(5);
  coda.push(15);
  coda.push(25);
  coda.push(50);
  coda.push(60);
  coda.push(40);
  coda.push(30);
  cout << "Dimensione coda:" << coda.size() <<endl;
 // Legge i valori dalla coda mentre non è vuota
  while (!coda.empty())
  {
   // Legge ed elimina il valore corrente dalla coda
    cout << coda.front() << endl;
   // Punta al valore successivo da leggere
    coda.pop();
  }
  cout << "Dimensione coda:" << coda.size() <<endl;
  return 0;
}

 

Esempio 15

#include <iostream>
#include <stack>

using namespace std;

int main()
{
  // Dichiarazione coda di valori interi di tipo LIFO
  stack <int> coda;
 // Inserimento valori nella coda
  coda.push(10);
  coda.push(20);
  coda.push(30);
  coda.push(5);
  coda.push(15);
  coda.push(25);
  coda.push(50);
  coda.push(60);
  coda.push(40);
  coda.push(30);
  cout << "Dimensione coda:" << coda.size() <<endl;
  while (!coda.empty())
  {
   // Legge ed elimina il valore corrente dalla coda
    cout << coda.top() << endl;
   // Punta al valore successivo da leggere
    coda.pop();
  }
  cout << "Dimensione coda:" << coda.size() <<endl;
  return 0;
}

 

Esempio 16

 

Esempio 17

Nella prossima lezione faremo un confronto tra C++ e Java.


<< Lezione precedente


  Clicca qui per scaricare i laboratori di questa lezione  (Per eseguire i laboratori installate Code Block sul vostro computer)


Laboratori di Logica di Programmazione in C

Share Button

Introduzione alla logica degli oggetti - Lezione 5

Gino Visciano | Skill Factory - 24/11/2018 14:02:07 | in Tutorials

Nelle lezioni precedenti abbiamo parlato di Polimorfismo dei metodi, definendo l'Overload lezione 3 e l'Override lezione 4,   in questa lezione parleremo di Polimorfismo degli oggetti.
Iniziamo intanto a dire che due oggetti si dicono Polimorfi  se sono simili.  Gli oggetti diventano simili quando si verifica uno dei seguenti casi:

1) una classe eredita un'altra classe;
2) più classi implementano la stessa interfaccia.

Nell'esempio seguente, le classi Persona, Dipendente, Manager e Dirigente, sono simili perché si ereditano tra loro:

La classe Persona è la più  generica, mentre la classe Dirigente è la più specializzata.

Nell'esempio seguente, le classi Rettangolo, Triangolo e Cerchio sono simili perché implementano la stessa interfaccia:

 

In C++ l'ereditarietà è multipla, quindi le interfacce non esistono, al loro posto si usano le classi astratte,  il polimorfismo basto sulle intefacce esiste solo in linguaggi di programmazione  come Java e C#, dove l'ereditarietà è singola e le interfacce si usano per superare questo limite.

Quando gli oggetti sono simili, diventano possibili operazioni di questo tipo:

Persona *dirigente=new Dirigente();

oppure

IFiguraGeometrica *triangolo=new Triangolo();

Nel primo esempio abbiamo istanziato un oggetto di tipo Dirigente, ma la variabile (puntatore) che contiene l'indirizzo dell'oggetto creato è di tipo Persona, un tipo molto più generico.
Nel secondo esempio abbiamo istanziato un oggetto di tipo Triangolo, ma la variabile (puntatore) che contiene l'indirizzo dell'oggetto creato è di tipo IFiguraGeometrica, che corrisponde ad una interfaccia oppure una classe astratta.

Questa proprietà degli oggetti simili  è molto utile quando volete passare allo stesso metodo oggetti simili;

COME PASSARE OGGETTI SIMILI AD UN METODO
Il Polimorfismo degli oggetti permette di passare oggetti simili allo stesso metodo, per evitare di creare un metodo per ogni tipo di oggetto da gestire.
Immaginate di voler stampare gli attributi di più oggetti di tipo diverso: Dipendente, Manager e Dirigente.
Senza il polimorfismo dovremmo creare tre metodi diversi:

stampaDipendente(Dipendente dipendente);
stampaManager(Manager manager);
stampaDirigente(Dirigente dirigente);

Invece, sfruttando il polimorfismo, possiamo creare un unico metodo a cui passiamo tutti e tre i tipi di oggetti simili, basta indicare come argomento il tipo più generico, che in questo caso è il Dipendente:

stampa(Dipendente dipendente);

questa sarebbe una semplificazione importante per chi deve stampare, perché dovrebbe ricordare il nome di un solo metodo anzicché tre nomi diversi.

Naturalmente il metodo stampa dovrà essere implementato in modo che riconosca quali sono i tipi di oggetti passati come argomenti e stamaprli in modo corretto.

L'esempio seguente mostra come creare il metodo getInformazioni con C++:

#include <string>
#include <iostream>
#include <sstream>
#include <typeinfo>

using namespace std;

class Persona {
    private:
        string classe;
        string nome;
        string cognome;
        int eta;
    public:
        void setNome(string nome){
            this->nome=nome;
        };
        void setCognome(string cognome){
            this->cognome=cognome;
        };
        void setEta(int eta){
            this->eta=eta;
        };
        string getNome(){
            return nome;
        }
        string getCognome(){
            return cognome;
        }
        int getEta(){
            return eta;
        }
       // getClasse() restituisce il tipo di classe dell'oggetto corrente
   
        string getClasse(){
            return this->classe;
        }

       /******
           setClasse() imposta l'attributo classe uguale al tipo di classe corrente, usando la funzione typeid(*this).name().
           *this è il puntatore che identifica l'oggetto corrente,
setClasse() deve essere virtuale perchè se viene 
           ereditato ,quando è invocato dalla classe derivata, deve comportarsi come se appartenesse ad essa, altrimenti
           il tipo restituito da setClasse() è sempre quello della classe più generica in cui è stato implementato.
       ******/ 

        virtual void setClasse(){
             this->classe=typeid(*this).name();
        }

        Persona(){
             setClasse();
        };
        Persona(string nome, string cognome, int eta){
            this->nome=nome;
            this->cognome=cognome;
            this->eta=eta;
           setClasse();
        }
};

// La classe Dipendente eredita la classe Persona e diventano simili
class Dipendente : public Persona {
    private:
        string ruolo;
        double stipendio;
    public:
        void setRuolo(string ruolo){
            this->ruolo=ruolo;
        };
        string getRuolo(){
            return ruolo;
        }
        void setStipendio(double stipendio){
            this->stipendio=stipendio;
        };
        double getStipendio(){
            return stipendio;
        }
        Dipendente(){
            setClasse(); // Ereditato dalla classe Persona, assegna all'attributo classe il tipo Dipendente
        };
        Dipendente(string nome, string cognome, int eta, string ruolo, double stipendio):Persona(nome, cognome, eta){
            this->ruolo=ruolo;
            this->stipendio=stipendio;
            setClasse(); // Ereditato dalla classe Persona, assegna all'attributo classe il tipo Dipendente
        }
};

// La classe Manager eredita la classe Dipendente e diventano simili, quindi per la proprietà transitiva Manager e simile anche a Persona
class Manager : public Dipendente {
        private:
        string areaResponsabilita;
    public:
        void setAreaResponsabilita(string areaResponsabilita){
            this->areaResponsabilita=areaResponsabilita;
        };
        string getAreaResponsabilita(){
            return areaResponsabilita;
        }
        Manager(){
            setClasse();
        };
        Manager(string nome, string cognome, int eta, string ruolo, double stipendio, string areaResponsabilita):
            Dipendente(nome, cognome, eta, ruolo, stipendio){
            this->areaResponsabilita=areaResponsabilita;
            setClasse();
        }
};

// La classe Dirigente eredita la classe Manager e diventano simili, quindi per la proprietà transitiva Dirigente e simile anche a Dipendente e Persona
class Dirigente : public Manager {
        private:
        string livelloFunzionale;
    public:
        void setLivelloFunzionale(string livelloFunzionale){
            this->livelloFunzionale=livelloFunzionale;
        };
        string getLivelloFunzionale(){
            return livelloFunzionale;
        }
        Dirigente(){
              setClasse(); // Ereditato dalla classe Persona, assegna all'attributo classe il tipo Manager

        }; 
        Dirigente(string nome, string cognome, int eta, string ruolo, double stipendio, string areaResponsabilita,string livelloFunzionale):
            Manager(nome, cognome, eta, ruolo, stipendio,areaResponsabilita){
            this->livelloFunzionale=livelloFunzionale;
            setClasse(); // Ereditato dalla classe Persona, assegna all'attributo classe il tipo Manager
        }
};
 

class GestisciDipendenti {
      public:
            // Il Metodo getInformazioni può ricevere come argomento oggetti di tipo Dipendente oppure oggetti simili di tipo Manager o Dirigente
            string getInformazioni(Dipendente *dipendente){
                       string infoPersona="";
                       stringstream sEta;
                       stringstream sStipendio;
                       string strEta,strStipendio;
                       sEta << dipendente->getEta();
                       sStipendio << dipendente->getStipendio();
                       strEta=sEta.str();
                       strStipendio=sStipendio.str();
                       // Se il puntatore *dipendente è di tipo Dirigente esegue uno static_cast a Dirigente e assegna all'attributo infoPersona le informazioni del Dirigente
                       if(dipendente->getClasse()==typeid(Dirigente).name()){
                          Dirigente *dirigente;
                          dirigente=static_cast<Dirigente *>(dipendente);
                          infoPersona = dirigente->getNome()+","+dirigente->getCognome()+","+strEta+","+dirigente->getRuolo()+","+strStipendio+","+
                          dirigente->getAreaResponsabilita()+","+dirigente->getLivelloFunzionale();
                          // Se il puntatore *dipendente è di tipo Manager esegue uno static_cast a Manager e assegna all'attributo infoPersona le informazioni del Manager
                          } else if(dipendente->getClasse()==typeid(Manager).name()){
                                     Manager *manager;
                                     manager=static_cast<Manager *>(dipendente);
                                     infoPersona = manager->getNome()+","+manager->getCognome()+","+strEta+","+manager->getRuolo()+","+strStipendio+","+
                                                               manager->getAreaResponsabilita();
                         // Se il puntatore *dipendente è di tipo Dipendente  assegna all'attributo infoPersona le informazioni del Dipendente 
                         } else{
                                   infoPersona = dipendente->getNome()+","+dipendente->getCognome()+","+strEta+","+dipendente->getRuolo()+","+strStipendio;
                        }
                        return infoPersona;
            }
};


int main(){
// Istanzio oggetto di tipo Dipendente
Dipendente *dipendente=new Dipendente("Marco","Rossi",30,"Programmatore",100.58);
// Istanzio oggetto di tipo Manager
Manager *manager=new Manager("Franco","Verdi",50,"Direttore Generale",200.58,"CED");
// Istanzio oggetto di tipo Dirigente
Dirigente *dirigente=new Dirigente("Carlo","Bianchi",50,"Direttore Generale",200.58,"CED","F3");
// Istanzio oggetto di tipo GestisciDipendenti che contiene il metodo getInformazioni
GestisciDipendenti *gd=new GestisciDipendenti();
// Dato che gli oggetti di tipo Dipendente, Manger e Dirigente sono Polimorfi (simili), possono essere passati al metodo getInformazioni impostando come
// argomento del metodo il tipo più generico dei tre,  il Dipendente: getInformazioni(Dipendente *dipendente) 
cout << "1) Dipendente" <<endl;
cout << gd->getInformazioni(dipendente) << endl;
cout << "2) Manager" <<endl;
cout << gd->getInformazioni(manager) << endl;
cout << "3) Dirigente" << endl;
cout << gd->getInformazioni(dirigente) << endl;
}

COME CREARE OGGETTI SIMILI ATTRAVERSO L'UTILIZZO D'INTERFACCE O CLASSI ASTRATTE
Le interfacce e le classi astratte sono strutture di programmazione simili,  perché entrambe contengono metodi astratti (non impelmentati) e non possono istanziare oggetti.

Le differenze principali tra loro sono due:

1)  le classi astratte possono contenere anche metodi già implementati, come le normali classi,  le interfacce no, a meno che non state usando Java 8 che permette d'implementare nelle interfacce anche metodi statici o di default;
2) le classi astratte si ereditano, mentre le interfacce s'implementano.

L'uso delle interfacce in alcuni linguaggi di programmazione ad oggetti come Java e C#, è necessario per superare il limite dell'ereditarietà è singola, che non permette di ereditare più classi contemporaneamente, mentre non è necessario in linguaggi di programmazione ad oggetti  dove l'ereditarietà è multipla, come in C++.

In realtà le classi astratte sono pattern (soluzioni applicative), che permettono di creare metodi che usano il risultato di altri metodi, detti astratti, la cui logica (comportamento) verrà implementata in futuro in una classe derivata.

Oggetti che ereditano la stessa classe astratta  oppure implementano la stessa interfaccia  diventano polimorfi, cioè simili.

Immaginate di voler creare un'applicazione specializzata per calcolare il perimetro e l'area delle seguenti figure geometriche:


Le quattro figure geometriche sono simili perché hanno in comune le seguenti caratteristiche:

1) corrispondono tutte ad un tipo di figura geometrica;
2) hanno tutte due coordinate x ed y che identificano la posizione in un piano bidimensionale;
3) hanno tutte un colore;
4) hanno tutte un perimetro ed un'area, che vengono calcolati diversamente per ogni tipo di figura geometrica, quindi devono essere implementati nelle classi di riferimento.

Tutte queste caratteristiche comuni possono essere raggruppate in una  classe astratta  come mostra il Diagramma di Classe seguente:

Successivamente la classe astratta FiguraGeometrica può essere ereditata dalle classi derivate Quadrato, Rettangolo, Triangolo e Cerchio che diventano simili tra loro.
In queste classi dovranno essere implementati i metodi astratti perimetro ed area, come mostra il Diagramma di Classe seguente: 

L'esempio seguente mostra come creare l'applicazione Geometria con C++, la classe FiguraGeometrica è una classe astratta che utilizza il metodo getInformazioni per restituire il perimetro e l'area delle figure geometriche istanziate.

Il metodo getInformazioni può usare i metodi perimetro ed area anche se non sono stati implementati perché sono astratti. Quando i due metodi verranno implementati nelle classi di riferimento forniranno il perimetro e l'area della figura geometrica corrente.

In C++ i metodi astrattti si dichiarano nel modo seguente:

virtual double perimetro()=0;
virtual double area()=0;

 

/*****************************
      Applicazione Geometria.cpp
****************************/

#include <string>
#include <iostream>
#include <sstream>
#include <math.h>

using namespace std;

// Classe che permette di definire la posizione nel piano delle figure geometriche in base alle coordinate x ed y
class Point {
private:
    int x,y;
public:
    Point(int x, int y){
    this->x=x;
    this->y=y;
    }
    getX(){
       return x;}
    getY(){
       return y;}
};

// Classe astratta che raggruppa la informazioni comuni a tutte le figure geometriche
class FiguraGeometrica {
private:
    string tipoFigura;
    Point *posizione;
    string colore;
public:
    string getTipoFigura(){
           return tipoFigura;
           }
    Point * getPosizione(){
           return posizione;
           }
    void setPosizione(Point *posizione){
           this->posizione=posizione;}
    string getColore(){
           return colore;}
    void setColore(string colore){
           this->colore=colore;
    }
    string getInformazioni(){
        stringstream sperimetro;
        stringstream sarea;
        stringstream sx;
        stringstream sy;
        sperimetro << perimetro();
// Utilizzo metodo astratto che verrà implementato successivamente nelle classi derivate
        sarea << area(); // Utilizzo metodo astratto che verrà implementato successivamente nelle classi derivate
        sx << posizione->getX();
        sy << posizione->getY();
        return tipoFigura+", posizione:"+sx.str()+", "+sy.str()+", "+colore+", perimetro:"+sperimetro.str()+", area:"+sarea.str();
    }
    virtual double perimetro()=0;
// Metodo astratto
    virtual double area()=0; // Metodo astratto
    FiguraGeometrica(string tipoFigura,Point *posizione,string colore){
        this->tipoFigura=tipoFigura;
        this->posizione=posizione;
        this->colore=colore;
    }
};

// La classe Quadrato eredita la classe astratta FiguraGeometrica e diventa simile a tutte le altre classi che erediteranno questa classe.
class Quadrato: public FiguraGeometrica {
private:
    double lato;
public:
    double getLato(){
        return lato;
    }
    void setLato(double lato){
        this->lato=lato;
    }
    // Sovrascrittura del metodo perimetro richiamato dal metodo getInformazioni ereditato dalla classe FiguraGeometrica per ottenere il preimetro del Quadrato
    double perimetro(){
       return lato*4;}
    // Sovrascrittura del metodo area richiamato dal metodo getInformazioni ereditato dalla classe FiguraGeometrica per ottenere l'area del Quadrato
    double area(){
       return pow(lato,2); // pow = potenza(base,esponete)
    }
    Quadrato(double lato,Point *posizione,string colore):FiguraGeometrica("Quadrato", posizione, colore){
        this->lato=lato;
    }
};

// La classe Rettangolo eredita la classe astratta FiguraGeometrica e diventa simile a tutte le altre classi che erediteranno questa classe.
class Rettangolo: public FiguraGeometrica {
private:
    double latoMinore;
    double latoMaggiore;
public:
    double getLatoMinore(){
        return latoMinore;
    }
    void setLatoMinire(double latoMinore){
        this->latoMinore=latoMinore;
    }
    double getLatoMaggiore(){
        return latoMaggiore;
    }
    void setLatoMaggiore(double latoMaggiore){
        this->latoMaggiore=latoMaggiore;
    }
    // Sovrascrittura del metodo perimetro richiamato dal metodo getInformazioni ereditato dalla classe FiguraGeometrica per ottenere il preimetro del Rettangolo
    double perimetro(){
       return (latoMinore+latoMaggiore)*2;}
    // Sovrascrittura del metodo area richiamato dal metodo getInformazioni ereditato dalla classe FiguraGeometrica per ottenere l'area del Rettangolo
    double area(){
       return latoMinore*latoMaggiore;
    }
    Rettangolo(double latoMinore,double latoMaggiore, Point *posizione,string colore):FiguraGeometrica("Rettangolo", posizione, colore){
        this->latoMinore=latoMinore;
        this->latoMaggiore=latoMaggiore;
    }
};

// La classe Triangolo eredita la classe astratta FiguraGeometrica e diventa simile a tutte le altre classi che erediteranno questa classe.
class Triangolo: public FiguraGeometrica {
private:
    double latoPrimo;
    double latoSecondo;
    double latoTerzo;
public:
    double getLatoPrimo(){
        return latoPrimo;
    }
    void setLatoPrimo(double latoPrimo){
        this->latoPrimo=latoPrimo;
    }
    double getLatoSecondo(){
        return latoSecondo;
    }
    void setLatoSecondo(double latoSecondo){
        this->latoSecondo=latoSecondo;
    }
    double getLatoTerzo(){
        return latoTerzo;
    }
    void setLatoTerzo(double latoTerzo){
        this->latoTerzo=latoTerzo;
    }
    // Sovrascrittura del metodo perimetro richiamato dal metodo getInformazioni ereditato dalla classe FiguraGeometrica per ottenere il preimetro del Triangolo
    double perimetro(){
       return latoPrimo+latoSecondo+latoTerzo;
       }
    // Sovrascrittura del metodo area richiamato dal metodo getInformazioni ereditato dalla classe FiguraGeometrica per ottenere l'area del Triangolo
    double area(){
       // Formula di Erone
       double semiPerimetro=perimetro()/2;
       return sqrt(semiPerimetro*(semiPerimetro-latoPrimo)*(semiPerimetro-latoSecondo)*(semiPerimetro-latoTerzo));
    }
    Triangolo(double latoPrimo,double latoSecondo,double latoTerzo, Point *posizione,string colore):FiguraGeometrica("Triangolo", posizione, colore){
        this->latoPrimo=latoPrimo;
        this->latoSecondo=latoSecondo;
        this->latoTerzo=latoTerzo;
    }
};

// La classe Cerchio eredita la classe astratta FiguraGeometrica e diventa simile a tutte le altre classi che erediteranno questa classe.
class Cerchio: public FiguraGeometrica {
private:
    double raggio;
public:
    double getRaggio(){
        return raggio;
    }
    void setRaggio(double raggio){
        this->raggio=raggio;
    }
    // Sovrascrittura del metodo perimetro richiamato dal metodo getInformazioni ereditato dalla classe FiguraGeometrica per ottenere il preimetro del Cerchio
    double perimetro(){
       return raggio*M_PI*2;} // M_PI = PI GRECO
    // Sovrascrittura del metodo area richiamato dal metodo getInformazioni ereditato dalla classe FiguraGeometrica per ottenere l'area del Cerchio

    double area(){
       return pow(raggio,2)*M_PI; // M_PI = PI GRECO, pow = potenza(base,esponete)
    }
    Cerchio(double raggio,Point *posizione,string colore):FiguraGeometrica("Cerchio", posizione, colore){
        this->raggio=raggio;
    }
};

int main() {
// Posizione Quadrato
Point *pointQuadrato=new Point(10,20);
// Quadrato(lato, posizione, colore)
Quadrato *quadrato=new Quadrato(25,pointQuadrato,"verde");
// Posizione Rettangolo
Point *pointRettangolo=new Point(60,80);
// Rettangolo(latoMinore, latoMaggiore, posizione, colore)
Rettangolo *rettangolo=new Rettangolo(25,40,pointRettangolo,"Blu");
// Posizione Trianangolo
Point *pointTriangolo=new Point(100,150);
// Triangolo(latoPrimo, latoSecondo, latoTerzo, posizione, colore)
Triangolo *triangolo=new Triangolo(40,30,20,pointTriangolo,"Rosso");
// Posizione Cerchio
Point *pointCerchio=new Point(100,150);
// Cerchio(lraggio, posizione, colore)
Cerchio *cerchio=new Cerchio(40,pointCerchio,"Grigio");
cout << quadrato->getInformazioni() << endl;
cout << rettangolo->getInformazioni() << endl;
cout << triangolo->getInformazioni() << endl;
cout << cerchio->getInformazioni() << endl;
}

Nella prossima lezione parleremo di Collection.


<< Lezione precedente           Lezione successiva >>


  Clicca qui per scaricare i laboratori di questa lezione  (Per eseguire i laboratori installate Code Block sul vostro computer)


Laboratori di Logica di Programmazione in C

Share Button

Introduzione alla logica degli oggetti - Lezione 4

Gino Visciano | Skill Factory - 05/10/2018 22:44:13 | in Tutorials

In questa lezione parliamo di Ereditarietà, che insieme all'incapsulamento ed il polimorfismo, è uno dei più importanti paradigmi dell'Object Oriented.

CHE COS'E' L'EREDITARIETA'
L'ereditarietà è una tecnica di riuso del codice che permette di specializzare una classe già esistente, per crearne una nuova.

La nuova classe si chiama classe derivata, mentre la classe ereditata si chiama classe superiore, come mostra il diagramma UML seguente:

L'ereditarietà si dice singola se la classe derivata può ereditare una sola classe, mentre si dice multipla se la classe derivata può ereditare più classi contemporaneamente. Ad esempio  il linguaggio C++ permette anche l'ereditarietà è multipla, mentre  Java e C# permettono solo l'ereditarietà singola, il diagramma UML seguente mostra un esempio di ereditarietà è multipla:

 

 

Un classe Persona che contiene gli attributi seguenti: id, nome, cognome, dataDiNascita, luogoDiNascita e sesso, può essere specializzata in una classe Dipendente che, oltre agli altributi della classe Persona contiene anche gli attributi seguenti: stipendio e ruolo, come mostra il diagramma UML seguente:

Con la classe Dipendete adesso si possono istanziare oggetti che oltre a contenere il ruolo e lo stipendio, contengono anche id, nome, cognome, dataDiNascita, luogoDiNascita e sesso, come mostra il diagramma UML seguente:

Di seguito implementiamo l'esempio appena visto con il linguaggio c++.

Prima di tutto creiamo una classe Data per gestire oggetti di tipo data, servirà in seguito per assegnare la data di nascita alla persona:

Adesso creiamo la classe Persona, che specializzaremo successivamente in Dipendente:

Infine creaiamo la classe Dipendente, che eredita la classe superiore Persona:

GESTIONE DEI COSTRUTTORI PARAMETRIZZATI
Se la classe superiore ha un costruttore parametrizzato, usato per inizializzare gli attributi, la classe derivata lo deve eseguire altrimenti non può funzionare correttamente.

Il diagramma UML seguente, mostra in che modo il costruttore della classe derivata esegue il costruttore parametrizzato della classe superiore:

Vediamo lo stesso esempio scritto in linguaggio C++:

class Persona {
private:
string sesso;
public:
int id;
string nome;
string cognome;
Data *dataDiNascita;
string luogoDiNascita;
void setMaschio(){
        this->sesso="maschio";
}
void setFemmina(){
         this->sesso="femmina";
}
string getSesso(){
          if(sesso=="") sesso="maschio";
          return this->sesso;
}
Persona(){
     this->dataDiNascita=new Data();
}
Persona(int id,string nome,string cognome, Data *dataDiNascita,string luogoDiNascita, string sesso){
     if(sesso=="maschio")setMaschio();
     else setFemmina();
     this->dataDiNascita=new Data();
     this->id=id;
     this->nome=nome;
     this->cognome=cognome;
     this->dataDiNascita=dataDiNascita;
     this->luogoDiNascita=luogoDiNascita;
}

};

class Dipendente : public Persona {
public:
double stipendio;
string ruolo;
Dipendente(){}
Dipendente(int id, string nome,string cognome, Data *dataDiNascita,string luogoDiNascita, string sesso, double stipendio, string ruolo):Persona(nome, cognome, dataDiNascita, luogoDiNascita, sesso){
    this->stipendio=stipendio;
    this->ruolo=ruolo;}
}
};

OVERRIDE (SOVRASCRITTURA) DI METODI EREDITATI DALLA CLASSE SUPERIORE
L'override è la tecnica che permette di sovrascrivere un metodo ereditato da una classe superiore per modificarne il comportamento all'interno della classe derivata. L'override, insieme all'overload può essere definito plimorfismo dei metodi.

Immaginiate di avere nella classe Persona il metodo getInformazioni() che restituisce i valori di tutti gli attributi della classe separti da una virgola. Se la classe Persona viene ereditata dalla classe Dipendente, questo metodo dovrà essere necessariamete sovrascritto altrimenti nell'elenco di attributi restituito mancherà lo stipendio ed il ruolo del Dipendente.

In C++ un metodo della della classe superiore per essere sovrascritto nella classe derivata, deve essere virtuale, come mostra l'esempio seguente:

class Persona {
private:
string sesso;
public:
int id;
string nome;
string cognome;
Data dataDiNascita;
string luogoDiNascita;
void setMaschio(){
        this->sesso="maschio";
}
void setFemmina(){
        this->sesso="femmina";
}
string getSesso(){
           if(sesso=="") sesso="maschio";
           return this->sesso;
}

// Metodo virtuale che verrà sovrascritto nella classe Dipendente
virtual string getInformazioni(){
             return nome + ", "+cognome+", "+dataDiNascita.getData()+", "+luogoDiNascita+", "+sesso;
}

 

Persona(){
     this->dataDiNascita=new Data();
}
Persona(int id,string nome,string cognome, Data *dataDiNascita,string luogoDiNascita, string sesso){
     if(sesso=="maschio")setMaschio();
     else setFemmina();
     this->dataDiNascita=new Data();
     this->id=id;
     this->nome=nome;
     this->cognome=cognome;
     this->dataDiNascita=dataDiNascita;
     this->luogoDiNascita=luogoDiNascita;
}
};

class Dipendente : public Persona {
public:
double stipendio;
string ruolo;
// Sovrascrittura del Metodo getInformazioni ereditato dalla classe Persona
string getInformazioni(){
           // Conversione double in stringa
           stringstream strStipendio;
           strStipendio << this->stipendio;
           return nome + ", "+cognome+", "+dataDiNascita.getData()+", "+luogoDiNascita+", "+
getSesso()+", "+strStipendio.str()+", "+ruolo;
}

Dipendente(){}
Dipendente(int id,string nome,string cognome, Data *dataDiNascita,string luogoDiNascita, string sesso, double stipendio, string ruolo):
    Persona(id, nome, cognome, dataDiNascita, luogoDiNascita, sesso){
    this->stipendio=stipendio;
    this->ruolo=ruolo;}
};

INCAPSULAMENTO DEGLI ATTRIBUTI E DEI METODI DI UNA CLASSE IN CASO DI EREDITARIETA'
Nell'esempio precedente, quando viene sovrascritto il metodo getInformazioni() della classe Dipendente, l'attributo sesso è stato sostituito dal metodo getSesso().
Questa operazione è necessaria perché l'attributo sesso della classe Persona è privato. Gli elementi privati di una classe sono visibili solo ai metodi della stessa classe, mentre non sono visibili in alcun caso ai metodi di altre classi.
In questo caso, sovrascrivendo il metodo getInformazioni() nella classe Dipendente, diventa un metodo esterno alla classe superiore e non può più vedere l'attributo sesso.
Il metodo getInformazioni() della classe Dipendente, per leggere il valore dell'attributo sesso, lo può fare solo attraverso il metodo getSesso() della classe Persona perchè è pubblico, come mostra l'immagine seguente:

Per poter usare direttamente l'attributo sesso nel metodo getInformazioni() della classe Dipendente, bisogna impostarlo protected, come mostra l'immagine seguente:

Per chiarire meglio il ruolo dei modificatori di accesso approfondiamo insieme il diagramma UML seguente:

Osservando il diagramma si capisce che una classe derivata che eredita una classe superiore, può usare attraverso un metodo, senza istanziare, tutti i suoi elementi pubblici e protetti.
Infatti il metodo metodotSeconda() della classe Seconda vede:
   attributoPublic;
   attributoProtected;
   metodoPrimoA();
   metodoPrimoC()
.

Mentre non vede l'attributoPrivate perché è privato. Se fosse necessario accedere a questo attributo lo potrebbe fare solo attraverso l'uso dei metodi:
    metodoPrimoA();
    metodoPrimoC().

Invece una classe utilizzatrice, per usare attraverso un suo metodo, gli elementi di un'altra classe, le deve prima istanziare e attraverso l'oggetto creato può vedere solo gli elementi pubblici della classe istanziata.
Infatti il metodo metodotTerza() della classe Terza, attraverso l'oggetto s vede:
   s->attributoPublic;
   s->metodoPrimoA();
   s->metodoSeconda().

Mentre non vede:
   attributoPrivate
   attributoProtected;
   metodoPrimoC()
.

Se fosse necessario accedere agli attributi oppure ai metodi non visibili lo potrebbe fare solo attraverso l'uso dei metodi:
   s->metodoPrimoA();
   s->metodoSeconda()
.

Per rendere efficace questo argomento, vi suggerisco di implementare con il linguaggio C++  le classi Prima, Seconda e Terza ed analizzarne attentamente il comportamento.

EREDITARIETA' MULTIPLA
Il linguaggio C++ permette di ereditare più classi contemporaneamente in questo caso si parla di ereditarietà multipla, vediamo un esempio:

Immaginate di avere una classe Persona a cui volete aggiungere le informazioni dell'indirizzo ed i riferimenti principali. In questo caso la classe Persona potrebbe ereditare una classe Indirizzo ed una classe Riferimenti, come mostra il diagramma UML seguente: 

class Indirizzo{
public:
    string via;
    string cap;
    string citta;
    string provincia;
    Indirizzo(){}
};

class Riferimenti{
public:
    string telefonoCasa;
    string telefonoUfficio;
    string cellulare;
    string email;
    string social_1;
    string social_2;
    string social_3;
    Riferimenti(){}
};

class Persona : public Indirizzo, public Riferimenti{
private:
   string sesso;
public:
   int id;
   string nome;
   string cognome;
   Data *dataDiNascita;
   string luogoDiNascita;
   void setMaschio(){
            this->sesso="maschio";
   }
   void setFemmina(){
           this->sesso="femmina";
   }
   string getSesso(){
           if(sesso=="") sesso="maschio";
           return this->sesso;
   }
   Persona(){
           this->dataDiNascita=new Data();
   }
   Persona(int id,string nome,string cognome, Data *dataDiNascita,string luogoDiNascita, string sesso,
                   string via, string cap, string citta, string provincia, string telefonoCasa, string telefonoUfficio,
                   string email,string facebook, string linkedin, string skillbook){
                   if(sesso=="maschio")setMaschio();
                   else setFemmina();
                   this->dataDiNascita=new Data();
                   this->id=id;
                   this->nome=nome;
                   this->cognome=cognome;
                   this->dataDiNascita=dataDiNascita;
                   this->luogoDiNascita=luogoDiNascita;
                   this->via=via;
                   this->cap=cap;
                   this->citta=citta;
                   this->provincia=provincia;
                   this->telefonoCasa=telefonoCasa;
                   this->telefonoUfficio=telefonoUfficio;
                   this->email=email;
                   this->social_1=facebook;
                   this->social_2=linkedin;
                   this->social_3=skillbook;
                   }
};

Nella prossima lezione parleremo di Polimorfismo degli oggetti.


<< Lezione precedente           Lezione successiva >>


  Clicca qui per scaricare i laboratori di questa lezione  (Per eseguire i laboratori installate Code Block sul vostro computer)


Laboratori di Logica di Programmazione in C

 

Share Button

Impariamo a programmare con JavaScript - Lezione 16

Gino Visciano | Skill Factory - 01/07/2018 18:11:25 | in Tutorials

Benvenuti alla sedicesima lezione, in questa lezione impareremo a gestire un databese con JavaScript ed useremo per lo scambio dei dati il formato JSON (JavaScript Object Notation).

Che cos'è JSON
La struttura di JSON (JavaScript Object Notation) è semplicissima e permette di rappresentare il contenuto di oggetti da usare per lo scambio di dati, soprattutto all'interno di applicazioni JavaScript/Ajax.
E' simile all' XML (eXtensible Markup Language), anche se questo linguaggio viene maggiormente usato per la descrizione di documenti oppure per fornire informazioni di configurazione.
Attenzione, non ponetivi la domanda meglio XML o JSON, perché il loro utilizzo dipende principalmente dalle esigenze che avete oppure dagli strumenti che state usando.

Nell'esempio seguente vediamo come si può usare JSON in JavaScript per memorizzare i dati di un prodotto:

var prodotto = {
     "id" : '1',
     "nome":"Penna",
     "prezzo":'0.5',
     "descrizione":"Penna colore rosso",
     "id_categoria":'3'
}

Per visualizzare il contenuto dell'oggetto prodotto dovete usare la sintassi seguente:

console.log(prodotto.id);
console.log(prodotto.nome);
console.log(prodotto.prezzo);
console.log(prodotto.descrizione);
console.log(prodotto.id_categoria);

 

Tipi di dati in JSON
JSON supporta i seguenti tipi di dati:

Boolean ( true e false )
    "pagata" : true
Numeri
    "eta"  : '34'
Stringhe
    "nome" :  "Mario"
Array
    "contatti" : ["08112428", "rossi.alba@gmail.com",  "skp.rossi.alba"]

Array di oggetti
var prodotti=[ {
     "id" : '1',
     "nome":"Penna",
     "prezzo":'0.5',
     "descrizione":"Penna colore rosso",
     "id_categoria":'3'
}, {
     "id" : '2',
     "nome":"Matita",
     "prezzo":'0.2',
     "descrizione":"Matita a righe gialle",
     "id_categoria":'3'
}
]

Per visualizzare il contenuto dell'Array di oggetti prodotti dovete usare la sintassi seguente:

for(var x=0;x<2;x++){
   console.log(prodotti[x].id);
   console.log(prodotti[x].nome);
   console.log(prodotti[x].prezzo);
   console.log(prodotti[x].descrizione);
  console.log(prodotti[x].id_categoria);
}

Oggetti nidificati
var dipendente= {
"nome":"Mario",

"cognome":"Rossi",
"dataDiNascita":"20/05/1985",
"luogoDiNascita":"Roma",

"indirizzoResidenza":{"strada":"Piazza Fiume, 30","cap":"00100","provincia":"RM"},
"indirizzoDomicilio":{"strada":"Via Montenapoleone, 20","cap":"20100","provincia":"MI"},

"ruolo":"Programmatore",
"titoloDiStudio":"Laurea Triennale",
"stipendio":1.586}

 

Per visualizzare il contenuto dell'Oggetto nidificato dipendente dovete usare la sintassi seguente:

console.log(dipendente.nome);
console.log(dipendente.cognome);

console.log(dipendente.dataDiNascita);
console.log(dipendente.luogoDiNascita);
console.log(dipendente.
indirizzoResidenza.strada);
console.log(dipendente.
indirizzoResidenza.cap);
console.log(dipendente.indirizzoResidenza.provincia);
console.log(dipendente.
indirizzoDomicilio.strada);
console.log(dipendente.
indirizzoDomicilio.cap);
console.log(dipendente.indirizzoDomicilio.provincia);
console.log(dipendente.ruolo);

console.log(dipendente.titoloDiStudio);
console.log(dipendente.stipendio);

 

Come convertire un oggetto JSON in un oggetto JavaScript
Se i dati organizzati in formato JSON sono in formato testo oppure stringa, per trasformarli in oggetti JavaScript potete usare il metodo JSON.parse(testo) oppure eval("("+testo+")"), come mostrano gli esempi seguenti:

 

Esempio 1
var strProdotto='{"id":1,'+'"nome":"Penna","prezzo":0.5,"descrizione":"Penna colore rosso","id_categoria":3}'
var objProdotto=JSON.parse(strProdotto);
console.log(objProdotto.id);
console.log(objProdotto.nome);
console.log(objProdotto.prezzo);
console.log(objProdotto.descrizione);
console.log(objProdotto.id_categoria);

 

Esempio 2
var strProdotto='{"id":1,'+'"nome":"Penna","prezzo":0.5,"descrizione":"Penna colore rosso","id_categoria":3}'
var objProdotto=eval("("+strProdotto+")");
console.log(objProdotto.id);
console.log(objProdotto.nome);
console.log(objProdotto.prezzo);
console.log(objProdotto.descrizione);
console.log(objProdotto.id_categoria);


Che cos'è il CRUD
Il CRUD è l'insieme delle operazioni che servono per Inserire, Leggere, Modificare e Cancellare i dati di una tabella di un databese.

CRUD è l'acronimo di:

  • Create     [Inserimento]
  • Read       [Lettura]
  • Update   [Modifica]
  • Delete    [Cancellazione]

Per creare un'applicazione che vi permette di gestire il CRUD servono gli strumenti seguenti:

  1. Visual Studio Code
  2. MySQL
  3. Express.js

Visual Studio Code
Visual Studio Code è un IDE (Integrated development environment), un ambiente di sviluppo integrato che serve per scrivere applicazioni.
Per scaricare questo programma clicca qui.

   

Dopo il download del file, dovete lanciarlo per installare il programma.

MySQL
MySQL è il nostro DBMS (Database Management System).
Per installare questo programma dovete scaricare XAMPPcliccate qui per avviare il download.

Per ricevere maggiori informazioni su MySQL cliccate qui.

Express.js
Express è un framework per creare applicazioni web Node.JS.
Per Installare il framework create la cartella app-prodotti, attivatela ed eseguite il comando:

npm install express

Laboratorio
In questo Laboratorio creiamo una semplice applicazione per gestire Prodotti.

Per iniziare create la cartella app-prodotti, spostatevi nella cartella ed installate i moduli seguenti:

npm install mysql

npm install body-parser

Dopo l'installazione dei due moduli, lanciate Visual Studio Code, selezionate  apri cartella, aprite la cartella app-prodotti e successivamente selezionate nuovo file (ctrl n).
 


Prima di tutto, con il comando require caricate tutti i moduli che servono per creare l'applicazione, come mostra l'immagine seguente:

Per salvare il file, premete alt f, cliccate sulla voce salva, inserite il nome AppProdotti.js e cliccate sul pulsante salva.
(La stessa cosa la potete fare premendo ctrl s)

Come creare il Server Web
Con il framework Express la creazione di un Server Web è un'operazione molto semplice, il codice JavaScript seguente vi permette di creare i metodi GET e POST ed avviare il server sulla porta 8090.

app.get('*', function (request, response) {
...
});
app.post('*' , function (request, response, next ) {

...
});
app.listen(8090, function () {
    console.log('listening on port 8090.');
});

I metodi app.get ed app.post si attivano ogni volta che arriva una richiesta di tipo GET oppure POST ed eseguono la funzione function (request , response) {...}.

L'argomento request è la request, l'oggetto che contiene i parametri inviati dal server, l'argomento response è la response l'oggetto usato per inviare le risposte al client.

Con Express per leggere i parametri da una request di tipo GET dovete usare la proprietà query, come mostra l'esempio seguente:

req.query.nomeparametro;

Se la request è di tipo POST dovete usare la proprietà body, come mostra l'esempio seguente:

req.body.nomeparametro;

La funzione app.listen è una funzione di callback, serve ad attivare il server web che restrà in ascolto sull'indirizzo ip di default 127.0.0.1 (localhost), utilizzando la porta 8090.  

I metodi app.get ed app.post verranno implementati dopo.

Come creare il Database dbprodotti
Per utilizzare la nostra applicazione dobbiamo creare il database dbprodotti, per farlo seguite le operazioni seguenti:
 

cliccate sull'icona di XAMPP

Quando appare la maschera seguente, avviate prima Apache e poi MySQL come indicato:

Successivamente per lanciare MySQL, dovete cliccare sul pulsante ADMIN.

La maschera seguente mostra come appare il Pannello di Controllo di MySQL, con a sinistra i Database creati e in alto le schede di gestione. 

A questo punto, selezionando la scheda SQL, potete creare il Database eseguendo uno alla volta i comandi SQL seguenti:

1) create database dbprodotti;

Ognuno dei comandi seguenti devono essere eseguiti insieme al comando:

use dbprodotti;

2) create table prodotti(id int primary key auto_increment, prodotto varchar(50) not null, id_categoria int not null);

3) create table categorie(id int primary key auto_increment, categoria varchar(50) not null);

4) 

INSERT INTO categorie (id, categoria) VALUES
(1, 'Abbigliamento'),
(2, 'Sport'),
(3, 'Arredamento'),
(4, 'Casalinghi'),
(5, 'Alimentari');

 

Come connettersi al Database MySQL
Per connettersi al database dbprodotti dovete creare l'oggetto connection utilizzando la funzione mysql.createConnection({ .. }), come mostra l'esempio seguente:

var connection = mysql.createConnection({
  host     : 'localhost',
  user     : 'nomeutente',
  password : 'password',
  database : 'nomedatabase'
});

Nel nostro caso:

var connection = mysql.createConnection({
  host     : 'localhost',
  user     : 'root',
  password : ''
  database : 'dbprodotti'
});

La password non è stata indicata perché l'utente root non ha una password.

Successivamente per attivare la connessione usate il comando seguete:

connection.connect(function(err){

if(!err) {
    console.log('Connessione eseguita con successo!!!');    
} else {
    console.log('Errore di connessione!!!');    
}
});

Per chiudere la connessione dovete usare il comando:

connection.end();

Come eseguire le operazioni di CRUD
Per eseguire le operazioni di CRUD dovete conoscere il linguaggio SQL, per chi ne avesse bisogno, può apprendere velocemente l'SQL cliccando sul link seguente:

Ricominciamo .. dal linguaggio SQL

Con JavaScript possiamo eseguire  comandi SQL con la funzione query, dell'oggetto connection.

Vediamo gli esempi principali: 

- Create (Inserimento)
connection.query("INSERT INTO prodotii (prodotto, id_categoria) VALUES (?, ?)"), ['Camicia', 1'], function(err, result) { ... }

  1. connection.query -> funzione JavaScript;
  2. INSERT INTO prodotii (prodotto, id_categoria) VALUES (?, ?) -> comando SQL;
  3. ?, ?  -> parametri ;
  4. ['camicia', 1] -> valori dei parametri;
  5. function(err, result) { ... } -> funzione eseguita dopo l'esecuzione del comando SQL;
  6. err -> si usa nel caso in cui l'esecuzione del comando SQL non va a buon fine;
  7. result -> si usa nel caso in cui l'esecuzione del comando SQL va a buon fine.


- Update (Modifica)
connection.query("UPDATE prodotti set id_categoria=? where id=?"), [2,1], function(err, result) { ... }

- Delete (Cancellazione)
connection.query("DELETE FROM prodotti where id=?"), [1], function(err, result) { ... }

- Read (Lettura e Visualizzazione)
connection.query("SELECT * FROM prodotti", function (err, result, fields) {
 if (err) throw err;
     for (var i in result) {
            console.log(result[i]);
     }
});

 

Share Button

Laboratori di Logica di Programmazione in C- Lezione 5

Gino Visciano | Skill Factory - 26/05/2018 17:17:57 | in Tutorials

Benvenuti, in questa lezione, attraverso i laboratori proposti, vedrete le principali tecniche di programmazione.


S O M M A R I O
LAB01: COME SOSTITUIRE IL COMANDO GOTO
LAB02: COME SI CREA UN MENU DI SCELTA UTILIZZANDO UN FLAG
LAB03: COME SI RIPETE UN PROGRAMMA
LAB04: TECNICHE DI SORT
LAB05: RICERCA SEQUENZIALE O LINEARE

LAB06: RICERCA DICOTOMICA O BINARIA
LAB07: ROTTURA DI CODICE
LAB 8: IMPAGINAZIONE DI UNA SEQUENZA DI DATI

ELENCO DELLE LEZIONI
DOWNLOAD LABORATORI


LAB01: COME SOSTITUIRE IL COMANDO GOTO
L'istruzione GOTO permette di saltare ad una particolare riga di programma oppure in una posizione del programma dove è presente un'etichetta.
L'uso del GOTO non è consigliato perchè rende i programmi poco leggibili, creando il famoso spaghetti huose, ovvero percorsi logici difficili da seguire e spesso incomprensibili.

Per evitare i problemi creati dall'istruzione GOTO la possiamo sostituire con un ciclo do - while. Il do deve essere posizionato nel punto dove saltare, perché sostituisce l'etichetta, mentre il while va messo al posto del GOTO, come mostra l'esempio seguente:

 

LAB02: COME SI CREA UN MENU DI SCELTA UTILIZZANDO UN FLAG
Per creare un menu di scelta vi servono le seguenti strutture di programmazione:
1) Ciclo do - while, per ripetere la visualizzazione del menu;
2) Struttura condizionale switch - case - default, per gestire la scelta fatta.

Un flag è una variabile numerica oppure booleana usata per ripetere un ciclo oppure per attivare o meno una scelta condizionale.

In C un flag corrispnde a vero se contiene un valore diverso da 0, altrimenti è falso.
In questo laboratorio usiamo un flag vero per visualizzare di nuovo il menu di scelta.
Impostando il flag a falso (scelta 5), il programma termina.

 

LAB03: COME SI RIPETE UN PROGRAMMA
Per creare un menu di scelta vi servono le seguenti strutture di programmazione:

1) Ciclo do - while esterno, permette di ripetere il programma;
2) Ciclo do - while interno, permette di inserire di nuovo la risposta se non si risponde con s oppure n;
3) Struttura condizionale if - else, viene usata per conrollare se la risposta fornita è s oppure n. Nel caso che i caratteri sono diversi da s oppure n viene stampato un messaggio d'errore e viene richiesta la risposta, altrimenti viene impostato il flag a false ed il controllo passa al do - while esterno.

La funzione tolower trasforma in minuscolo il valore della risposta.
 

LAB04: TECNICHE DI SORT
Per ordinare una collezione di dati, esistono diverse tecniche di sort, le più usate sono le seguenti:

- Selection Sort
- Bubble Sort
- Insertion Sort
- Merge Sort
- Quick Sort

Per poter eseguire il sort di una collezione di dati è importate confrontare tutti gli elementi da ordinare in modo crescente o decrescente e scambiarli (SWAP) se le loro posizioni non corrisponde al tipo di ordinamento scelto.

Lo SWAP è la tecnica che serve per invertire il contenuto di due variabili, questa tecnica richiede l'uso di una variable temporanea usata per conservare provvisoriamente il valore di un delle due variabili da invertire. L'immagine seguente mostra come si applica lo SWAP:

Negli esempi seguenti vediamo un selection sort ed bubble sort applicati ad array numerici.

SELECTION SORT

BUBBLE SORT

 

LAB05: RICERCA SEQUENZIALE O LINEARE
Per ricercare un valore in una collezione di dati, come ad esempio un vettore d'interi, serve un ciclo for che permette di scorrere tutti i valori della collezione e confrontarli con il valore cercato, come mostra l'esempio seguente:

LAB06: RICERCA DICOTOMICA O BINARIA
Per ricercare un valore in una collezione di dati, come ad esempio un vettore d'interi, oltre alla ricerca sequenziale potete usare anche la ricerca dicotomica molto più performante.
Per esegure questo tipo di ricerca detta anche binaria la collezione di dati deve essere ordinata.
L'esempio seguente mostra come usare questa tecnica per ricercare un valore in un vettore d'interi ordinato in modo crescente:

 

LAB07: ROTTURA DI CODICE
La  rottura di codice è una tecnica applicata per analizzare sequenze di dati organizzate in base ad una chiave comune chiamata codice. Tutte le volte che la chiave scelta cambia, si verifca una rottura di codice.
Ad ogni cambiamento di codice vengono visualizzate le statistiche della chiave corrente (conteggio, somma, media, max e min) e si ricominciano a calcolare quelle della nuova chiave.
L'immagine seguente mostra la tecnica della rottura di codice applicata ad un vettore d'interi, in questo caso alla chiave corrisponde il valore del numero.

L'esempio seguente mostra come calcolare la frequenza e la somma dei numeri interi uguali presenti in un vettore, utilizzando la rottura di codice:

LAB 8: IMPAGINAZIONE DI UNA SEQUENZA DI DATI
L'impaginazione è una tecnica di programmazione fondamentale per visualizzare sequenze di dati memorizzati in array oppure tabelle.
L'impaginazione deve permettere l'organizzazione dei dati da visualizzare in pagine di lunghezza predefinita e consentire la navigazione tra le pagine con la seguente modalità:

- Vai alla prima pagina;
- Vai all'ultima pagina;
- Vai alla pagina precedente;
- Vai alla pagina successiva.

 


Per gestire la navigazione sono importanti le informazioni seguenti:

1) Numero di righe per pagina;
2) Numero totale di pagine;
3) Pagina corrente;
4) Offset, valore che corrisponde alla posizione della prossima riga da leggere.

Per calcolare il numero totale di pagine dobbiamo dividere il numero totale di righe, della serie di dati da visualizzare, per la lunghezza della pagina e arrotondare per eccesso, come mostra la formula seguente:

totalePagine=ceil(totaleRighe/lunghezzaPagina);

L'Offset lo possiamo calcolare con la formula seguente:

offset=(paginaCorrente-1)*lunghezzaPagina;

L'esempio seguente mostra come impaginare un vettore di nomi:

 


LABORATORI DI LOGICA DI PROGRAMMAZIONE IN C
LEZIONE 1
LEZIONE 2
LEZIONE 3
LEZIONE 4
LEZIONE 5


D O W N L O A D   L A B O R A T O R  I
Clicca qui per il download dei laboratori.


Introduzione alla logica degli Oggetti (Per imparare a programmare ad oggetti)


Share Button
TOP