domenica 30 dicembre 2012

Definire funzioni membro virtuali

Un oggetto di una classe derivata è anche un membro di una classe di base. Per esempio, il programma Capo virtuale, l'oggetto Capo è anche un oggetto Nemico. Tutto ciò ha senso in quando si tratta solo di un tipo di nemico speciale. Inoltre ha senso in quanto l'oggetto Capo ha tutti i membri dell'oggetto Nemico. Bene, e allora? Poiché una classe derivata è anche un membro della classe di base, si può usare un puntatore alla classe di base per puntare un oggetto della classe derivata. Questo è ciò che faccio in main() con la seguente istruzione, la quale istanzia un oggetto Capo su heap e crea un puntatore a Nemico che punti all'oggetto Capo.
Nemico* pCattivo = new Capo();

Cosa vuol dire tutto questo? E' utile a permetterci di gestire l'oggetto senza doverne conoscere il tipo esatto. Per esempio di può avere una funzione che accetta un puntatore a Nemico e può funzionare sia con Nemico che con Capo oggetti. La funzione non deve conoscere l'esatta tipologia di oggetto passato, può funzionare con oggetti che producono risultati diversi a seconda di quale sia utilizzato. Ma ora analizziamo cosa accade nella successiva riga di codice.
pCattivo - > Fastidio();

Invece mostra una linea di testo Il nemico vuole combatterti. Quindi non è stata richiamata la funzione Fastidio() dell'oggetto Capo ma dell'oggetto Nemico, nonostante sia stata superata dalla funzione Fastidio() nella classe di Capo. Questo accade come risultato di un legame precedente nel quale l'esatta funzione è legata al tipo di puntatore, in questo caso Nemico. Ciò di cui si ha bisogno è una funzione membro chiamata sul tipo di oggetto puntato, e non fissato dal puntatore. In questo si ottiene la flessibilità del legame successivo attraverso funzioni virtuali, che ottiene con il comportamento polimorfico. Per creare una funzione membro virtuale, si aggiunge semplicemente la parola chiave virtual prima del nome della funzione nella sua dichiarazione. Questo è ciò che viene fatto in Nemico con la seguente istruzione.
void virtual VFastidio() const
{ cout << “Il nemico vuole combatterti.\n”; }

Questo significa che VFastidio() è una funzione virtuale. E' virtuale in Nemico, e viene ereditata in Capo. Questo impila che VFastidio() in Capo possa superare con la seguente istruzione la funzione ereditata. La corretta versione di VFastidio() viene chiamata (in base al tipo di oggetto) e non sarà fissata dal tipo di puntatore.
void virtual VFastidio() const
{ cout << “Il capo vuole mettere fine alla tua esistenza.\n”; }

La prova del comportamento polimorfico viene in main() con la seguente istruzione, nel quale la funzione VFastidio() definita in Capo viene chiamata ed il testo “Il capo vuole mettere fine alla tua esistenza”. Viene mostrato su schermo.

pCattivo - > VFastidio();

Definire Distruttori virtuali

Quando si usa un puntatore alla classe di base per puntare un oggetto di una classe derivata, si può avere un potenziale problema. Quando viene cancellato il puntatore, solo il distruttore della classe viene chiamato per l'oggetto. Questo può condurre a risultati disastrosi poiché il distruttore della classe derivata è necessario per liberare la memoria ( come fa il distruttore di Capo). La soluzione come si può indovinare, è di rendere il distruttore della classe virtuale. In questo modo viene chiamato il distruttore della classe, il qual conduce (sempre) alla chiamata del distruttore della classe di base, dando ad ogni classe la possibilità di ripulirsi. La teoria viene messa in pratica quando si crea il distruttore virtuale della classe Nemico.
virtual ~Nemico(){ cout << “m_pDanno cancellato”; delete m_pDanno;}
Quando viene cancellato il puntatore che punta alla classe Capo con la seguente istruzione, il distruttore della classe Capo viene chiamato, il quale libera la memoria su heap dei dati m_pMultidanno e mostra il messaggio.
delete pCattivo;

Quindi viene chiamato il distruttore di Nemico, il quale libera la memoria su heap da m_pDanno e mostra il messaggio m_pDanno cancellato. L'oggetto è distrutto, e tutte le memorie associate ad esso sono cancellate.

venerdì 28 dicembre 2012

Presentare il Polimorfismo

Uno dei pilastri della OOP è il polimorfismo, con il quale le funzioni membro producono risultati differenti a seconda del tipo di oggetto nel quale sono stati chiamate in causa. Per esempio, un gruppo di nemici che il giocatore sta affrontando, il gruppo è formato da oggetti di tipo diverso imparentati tra loro dall'ereditarietà, i nemici ed i loro capi. Attraverso la magia del polimorfismo, si possono richiamare le stesse funzioni membro per ogni cattivo del gruppo, definire come attaccare il giocatore, e per ogni oggetto valutarne gli effetti. Una chiamata all'oggetto nemico produce un attacco debole, mentre una chiamata al capo produce risultati diversi, ad esempio un potente attacco. Questo può assomigliare al superamento, ma il polimorfismo è diverso, in quanto le chiamate delle funzioni sono dinamiche e gli effetti valutati in tempo reale, a seconda del tipo di oggetto. Il modo migliore per comprendere questo meccanismo è mostrarne esempi concreti.

Presentare il programma Capo virtuale

Il programma Capo virtuale dimostra come si usano le funzioni membro virtuali e come raggiungere il comportamento polimorfico. Mostra cosa accade quando si usa un puntatore alla classe di base per chiamare funzioni virtuali e non virtuali. Mostra anche l'uso dei distruttori verticali che assicurano la corretta distruzione degli oggetti richiamati tramite puntatori alla classe di base.
// Capo virtuale
//dimostra funzioni virtuali
#include<iostream>
using namespace std;
class Nemico
{public:
            Nemico(int danno=10){ m_pDanno = new int(danno); }
            virtual ~Nemico(){ cout << “m_pDanno cancellato”; delete m_pDanno;}
            void Fastidio() const
              { cout << “Il nemico vuole combatterti.\n”; }
           void virtual vFastidio() const
              { cout << “Il nemico vuole combatterti.\n”; }
protected: int* m_pDanno;
};
class Capo: public Nemico
{
public: Capo( int multi =2){ m_pMultiDanno = new int(multi); }
           virtual ~Capo(){ cout << “m_pMultiDanno cancellato”; delete m_pMultiDanno;}
            void Fastidio() const
             { cout << “Il capo vuole mettere fine alla tua esistenza.\n”; }
           void virtual vFastidio() const
            { cout << “Il capo vuole mettere fine alla tua esistenza.\n”; }
protected: int* m_pMultiDanno;
};
int main()
{ cout << “Puntatore a Nemico che punta a oggetto Capo:\n”;
   Nemico* pCattivo = new Capo();
   pCattivo - > Fastidio();
   pCattivo - > vFastidio();
 cout << “Cancelliamo puntatore a Nemico:\n”;
  delete pCattivo;
  pCattivo = 0;

return 0;
}

Uso dell'operatore di Assegnazione sovraccaricato e costruttore Copia nelle classi derivate

E' già stato spiegato come scrivere un operatore di assegnazione sovraccaricato e un costruttore copia per una classe. Tuttavia, scriverli per una classe derivata richiede un leggero lavoro ulteriore in quanto non sono ereditati dalla classe di base. Quando si sovraccarica l'operatore di assegnazione nelle classi derivate, di solito si richiama l'operatore di assegnazione delle classi base, utilizzando una chiamata esplicita con il nome della classe di base quale prefisso. Se Capo è derivato da Nemico, la funzione dell'operatore di assegnazione definita in Capo di solito recita:
Capo& operator=(const Capo& b)
{ Nemico::operator=(b); //gestisce i dati membro ereditati da Nemico
// di seguito bisogna gestire i dati membro di Capo }

La chiamata esplicita dell'operatore di assegnazione di Nemico gestisce i dati membro ereditati da esso. Ma il resto della funzione deve occuparsi dei dati definiti in Capo. Per il costruttore Copia, di solito si effettua una chiamata al costruttore Copia della classe di base. Se Capo è derivato da Nemico, il costruttore di copia definito in esso, si scrive:
Capo (const Capo& b): Nemico(b){
// si gestiscono i dati membro definiti in Capo }

Dalla chiamata del costruttore Copia di Nemico con Nemico(b), la copia dei dati membro di Nemico viene messa nel nuovo oggetto Capo. Nel resto della funzione di Capo del costruttore copia si bada a tutti i dati membro dichiarati solo in Capo del nuovo oggetto.

giovedì 27 dicembre 2012

Chiamata e superamento delle Funzioni membro classi Base

Non si viene bloccati su ogni membro funzione delle classi di base ereditati dalle classi derivate così come sono. Ma si possiede l'opzione di una personalizzazione di come vengano ereditate le funzioni membro e come esse lavorino nelle classi derivate. E' possibile superarle attraverso nuove definizioni all'interno delle classi derivate. Si può esplicitare una chiamata alla classe di base da ogni funzione membro della classe derivata.

Presentare il programma Capo superiore

Il programma Capo superiore dimostra la chiamata ed il superamento delle funzioni membro della classe di base in una classe derivata. Il programma crea un nemico che infastidisce il giocatore e lo attacca. In seguito il programma crea un Capo mediante una classe derivata. Anche il Capo infastidisce il giocatore e lo attacca, ma la cosa interessante è che il suo modo di approcciarsi ed attaccare viene modificato rispetto al Nemico (rendendolo più resistente). Questi cambiamenti sono ottenuti mediante il superamento della funzione derivata rispetto alla funzione della classe di base.
//Capo superiore
//dimostra la chiamata ed il superamento delle funzioni membro di base
#include <iostream>
using namespace std;
class Nemico
{
          public: Nemico(int danno = 5): m_Danno(danno){}
                     void Fastidio() const { cout << “Il nemico vuole combatterti.\n”; }
                     void Attacco const
                    { cout << “Attacco infligge” << m_Danno << “ punti danno.\n”;}
         private: int m_Danno;
};
class Capo: public Nemico
{
          public:
                   Capo(int danno= 20): Nemico(danno){} //chiamata al costruttore di base con argomento
                   void Fastidio() const { cout << “Il capo vuole mettere fine alla tua esistenza.\n”; }
                  void Attacco() const
                         { Nemico::Attacco();
                            cout << “Ride di te.\n”; }
};
int main()
{
   cout << “Crea un nemico.\n”;
   Nemico nemico1;
   nemico1.Fastidio();
   nemico1.Attacco();

   cout << “\n Crea un capo. \n”;
   Capo capo1;
   capo1.Fastidio();
   capo1.Attacco();

return 0;
}

domenica 23 dicembre 2012

Controllo accesso sotto Ereditarietà

Quando viene derivata una classe da un'altra è possibile controllare quanto accesso la classe derivata ha sui membri della classe di base. Per la stessa ragione, si vuole fornire sono la quantità di accesso necessario ai membri della classe base, nel resto del programma, che possa servire alla classe derivata. Non è una coincidenza se vengono utilizzati gli stessi modificatori di accesso visti in precedenza (public, private e protected).

Presentare il programma Semplice Capo 2.0

Il programma Semplice Capo 2.0 è un'altra versione del programma visto in precedenza. Ma in questa nuova versione, la quale fornisce gli stessi risultati all'utente, ma il codice è leggermente diverso in quanto sono state messe delle restrizioni sui membri della classe base.
//Semplice Capo 2.0
//Dimostrazione del controllo di accesso con ereditarierà
 #include <iostream>
 using namespace std;
 class Nemico
 {
     public:
               Nemico(): m_Danno(10){}
               void Attacco const
               { cout << “Attacco infligge” << m_Danno << “ punti danno.\n”;}
    protected: int m_Danno;
};
class Capo: public Nemico
{
    public:
              Capo():m_MultiDanno(3){}
              void AttaccoSpeciale() const
             { cout << “Attacco Speciale infligge” << (m_MultiDanno * m_Danno);
               cout << “ punti danno.\n”;}
   private: int m_MultiDanno;
};

int main()
{
   cout << “Crea un nemico.\n”;
   Nemico nemico1;
   nemico1.Attacco();
  
  cout << “\n Crea un capo. \n”;
  Capo capo1;
  capo1.Attacco();
  capo1.AttaccoSpeciale();
return 0;
}

Presentare il programma Semplice Capo

Il programma Semplice Capo dimostra il concetto di ereditarietà. In esso, viene definita una classe di nemici inferiori, Nemico. Da questa classe viene derivata una nuova classe per i Capi più resistenti che il giocatore deve affrontare. Quindi viene istanziato un oggetto Nemico e richiamata la sua funzione membro Attacco(). Di seguito viene istanziato un oggetto Capo, del quale è possibile richiamare la funzione Attacco(), in quanto eredita la funzione membro da Nemico. Infine viene richiamata la funzione membro AttaccoSpeciale() definita solo per la classe Capo. Mentre la classe Nemico non ha accesso a questa funzione in quanto esclusiva del capo.
//Semplice Capo

//Dimostrazione ereditarietà

   #include <iostream>

   using namespace std;

   class Nemico

   {

          public: int m_Danno;

          Nemico(): m_Danno(10){}

          void Attacco const

          { cout << “Attacco infligge” << m_Danno << “ punti danno.\n”;}

   };

 class Capo: public Nemico

 {

          public: int m_MultiDanno;

         Capo():m_MultiDanno(3){}

         void AttaccoSpeciale() const

         { cout << “Attacco Speciale infligge” << (m_MultiDanno * m_Danno);

            cout << “ punti danno.\n”;}

  };

int main()

{

   cout << “Crea un nemico.\n”;

   Nemico nemico1;

   nemico1.Attacco();



   cout << “\n Crea un capo. \n”;

   Capo capo1;

   capo1.Attacco();

   capo1.AttaccoSpeciale();

return 0;

}

sabato 22 dicembre 2012

Ereditarietà e polimorfismo

Le classi sono un esempio perfetto per rappresentare entità nel gioco che hanno attributi e comportamenti. Ma le entità nei giochi sono spesso correlate tra loro. In questi post saranno introdotti i concetti di ereditarietà e polimorfismo, i quali permettono di esprimere tali collegamenti e possono far costruire classi di gioco ancora più semplici ed intuitive. I concetti espressi saranno:
  • Derivare una classe da un'altra
  • Usare i dati membro e funzioni di una classe ereditata
  • maneggiare i membri della classe di base
  • Definire funzioni virtuali per abilitare il polimorfismo
  • Definire funzioni virtuali pure per le classi astratte
  • Suddividere il codice in file multipli

Introdurre l'Ereditarietà

Uno degli elementi chiave della OOP è l'ereditarietà, la quale permette di derivare una classe nuova da una esistente. Quando viene fatto, la nuova classe eredita (ottiene) i dati membro e le funzioni membro della classe esistente. E' come ottenere qualcosa che funziona con un lavoro gratuito della classe esistente. L'ereditarietà è molto utile quando si vuole creare una versione più specializzata di una classe esistente poiché si vogliono solo aggiungere nuovi dati membro e funzioni per estenderla. Un esempio è, immaginiamo di avere la classe Nemico che definisce un avversario nel gioco, la quale ha una funzione membro Attacco() e il dato membro m_Danno. Da questa si vuole ricavare la classe Capo, per un capo dei Nemici. Questo significa che la classe Capo possiede automaticamente una funzione Attacco() e un dato m_Danno senza dover scrivere del codice. Tuttavia per rendere il capo più resistente, viene aggiunta la funzione AttaccoSpeciale() e il membro dati Multi_Danno alla classe Capo. Uno dei maggiori vantaggi dell'ereditarietà è la possiiblità di riutilizzo delle classi già scritte. Il quale si riassume nei benefici:
  • Minore lavoro. Non è necessario definire funzionalità già possedute. Una volta che una classe definisce funzioni di base per le altre classi, il codice non deve essere riscritto di nuovo.
  • Meno errori. Un classe priva di bachi, può essere riutilizzata senza doverne cercare altri nel nuovo codice.
  • Un codice più leggero. Poiché le funzionalità di base delle classi esistono nel programma, non si deve ripercorrere lo stesso codice più volte, rendendo la scrittura del programma più leggera e facile da comprendere.
Molte entità nei giochi chiamano a gran voce l'ereditarietà delle classi. Che si tratti di uno squadrone di nemici, o una serie di veicoli comandati dall'utente, o un inventario di armi che il giocatore possiede. Tutti possono essere definiti come un gruppo di elementi connessi tra loro, risulta in una programmazione più veloce.