/* Abbiamo visto come le classi siano una definizione astratta degli
 * oggetti da istanziare, i quali poi avranno ognuno una copia personale
 * sia dei metodi che delle variabili, per cui scrivendo in una variabile
 * di un oggetto, non si cambia il valore delle copie di quella variabile
 * negli altri oggetti istanza della stessa classe. Infatti se scriviamo
 * in cane1.numerozampe non si modifica cane2.numerozampe, essendo queste
 * due variabili indipendenti, e tra l'altro inaccessibili dall'esterno
 * del proprio oggetto, essendo private.
 * Pero' tale variabile si puo' definire statica, ossia si puo' fare in
 * modo che tale variabile esista al massimo in una copia, anche se si
 * istanziano svariati oggetti. In questo modo, tale variabile sara'
 * condivisa da tutti gli oggetti istanziati dalla classe, e scrivere
 * in essa da uno degli oggetti significhera' cambiarne il valore in tutti
 * gli altri. Per dichiarare statica una variabile, basta usare "static":
 *
 * static int numerozampe;
 *
 * Vediamo il suo uso.
 * NOTA: Questo sorgente presenta errori di link in compilazione, in quanto
 * la classe dovrebbe essere compilata in un file oggetto .o a parte e
 * linkata poi all'oggetto del main. Per semplicita' nei sorgenti C++ visti
 * nel corso abbiamo messo tutto nello stesso sorgente, ma in questo caso
 * si presenta (giustamente) un errore. Il nostro scopo e' quello di imparare
 * il Java, d'altronde, per cui non ho voluto complicare ulteriormente le
 * cose. Sappiate comunque che in Java vengono automaticamente creati dei
 * file separati per le singole classi, anche se sono tutte nello stesso
 * sorgente, e non occorre linkarle: si caricheranno da sole al momento
 * dell'esecuzione.
 * Potete trovare l'eseguibile nell'archivio CJAPCEXE.ZIP in linea sul sito
 * www.anfitreatro.it, o potete ottenerlo se siete pratici di linkaggio.
 */

#include <iostream.h>    // Header necessario per usare CIN e COUT
			 // Questo e' un commento C++ ad una sola linea

class animale {	               // Definisco la classe animale
    static int numerozampe;    // variabile STATICA e privata.
 public:		       // La parte che segue e' PUBLIC
    void mettizampe(int l);    // Questi sono i prototipi delle funzioni
    int leggizampe(void);
 };


// Ora scriviamo le funzioni (metodi) della classe animale:

/*-------------------------------------------------------------------------*
 * mettizampe: definisce il numero di zampe dell'animale.
 *             parametri: in entrata il num. di zampe in formato int.
 *-------------------------------------------------------------------------*/

void animale::mettizampe(int l)   // mettizampe() e' un metodo di animale
{
  numerozampe = l; // Scrive il valore nella variabile privata "numerozampe".
}

/*-------------------------------------------------------------------------*
 * leggizampe: legge e restituisce il num. di zampe dell'animale.
 *             parametri: in uscita il num. di zampe in formato int.
 *-------------------------------------------------------------------------*/

int animale::leggizampe(void)  // leggizampe() e' un metodo di animale
{
  return numerozampe;
}

///////////////////////////////////////////////////////////////////////////
//                            Il main...
///////////////////////////////////////////////////////////////////////////

int main(void)
{

  animale cane1,cane2;	// Istanzio 2 oggetti della classe animale

// Azzeriamo usando i 2 mettizampe come se numerozampe non fosse static.

  cane1.mettizampe(0);       // Azzeriamo
  cane2.mettizampe(0);       // Non servirebbe, gia' azzerato prima.

// Scriviamo 40 in cane1.numerozampe

  cane1.mettizampe(40);       // In realta' abbiamo modificato anche cane2.

// Verifichiamo che la variabile, essendo static, e' una sola, condivisa,
// infatti sia cane1 che cane2 risulteranno avere 40 zampe.

  cout << "\nStato dell'animale cane1: zampe = " << cane1.leggizampe();
  cout << "\nStato dell'animale cane2: zampe = " << cane2.leggizampe();

  return 0;	// main() restituisce 0
}

/* Fate molta attenzione all'uso di static, perche' cambia molto la logica
 * di funzionamento delle classi.
 */