/* In alcuni casi potremmo avere la necessita' di passare subito dei
 * parametri al costruttore di una classe. E' possibile:
 *
 * class animale {	   // Definisco la classe animale
 *     ...
 *  public:		// La parte che segue e' PUBLIC (visibile da tutti)
 *     animale(int zamp);         // Costruttore con parametri
 *     ~animale(void);            // Distruttore
 *     ...
 *  };
 *
 * // Ecco il costruttore
 *
 * animale::animale(int zamp)
 * {
 *   lunghezza = 0
 *   numerozampe = zamp;                 // Il num. zampe lo metto subito
 *   cout << "animale inizializzato con " << zamp << " piedi\n";
 * }
 *
 * In effetti, se si crea un dato animale, il numero di zampe lo possiamo
 * sapere subito... mentre la lunghezza puo' variare con l'eta', quindi
 * la metteremo dopo.
 * Per passare il valore al momento della dichiarazione si puo' fare in
 * due modi:
 *
 * 1)   animale cane = animale(4);
 * 2)   animale cane(4);
 *
 * Il secondo, essendo il piu' breve, risulta essere il piu' usato.
 */

#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
    float lunghezza;    // Questa parte e' PRIVATE di default
    int numerozampe;
 public:		// La parte che segue e' PUBLIC (visibile da tutti)
    animale(int zamp);         // Costruttore con parametri
    ~animale(void);            // Distruttore
    void mettilungh(float i);  // Questi sono i prototipi delle funzioni
    void mettizampe(int l);    // (o metodi) della nostra classe.
    float leggilungh(void);
    int leggizampe(void);
 };


// Ora scriviamo i metodi della classe animale:

// Ecco il costruttore. Parametri: in entrata il numero di zampe (int).

animale::animale(int zamp)
{
  lunghezza = 0;
  numerozampe = zamp;                 // Il num. zampe lo metto subito
  cout << "animale inizializzato con " << zamp << " piedi\n";
}

// Ecco il distruttore

animale::~animale(void)
{
   cout << "animale distrutto\n";
}

/*-------------------------------------------------------------------------*
 * mettilungh: definisce la lunghezza dell'animale.
 *             parametri: in entrata la lunghezza in formato float.
 *-------------------------------------------------------------------------*/

void animale::mettilungh(float i)
{
  lunghezza = i;   // Scrive il valore nella variabile privata "lunghezza".
}

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

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

/*-------------------------------------------------------------------------*
 * leggilungh: legge e restituisce la lunghezza dell'animale.
 *             parametri: in uscita la lunghezza in formato float.
 *-------------------------------------------------------------------------*/

float animale::leggilungh(void)
{
  return lunghezza;
}

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

int animale::leggizampe(void)
{
  return numerozampe;
}

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

int main(void)
{

 float temp;	// Variabile temporanea che usiamo per le lunghezze.
 int temp2;	// Idem, per il num. zampe.

// Ora possiamo dichiarare alcuni oggetti di tipo animale e usarli:

 animale cane1(4),cane2(4);	// ecco che istanzio 3 animali...
 animale millepiedi(1000);      // ossia creo degli esemplari dalla
				// classe "astratta".
				// (Passandogli subito un parametro).

// Gli altri parametri li chiediamo all'utente.

  cout << "\nLunghezza cane 1? ";   // Stampa la frase come un printf()
  cin >> temp;                      // Legge il valore come scanf()
  cane1.mettilungh(temp);           // Passa a mettilungh la variabile temp
  cout << "Lunghezza cane 2? ";	    // Stampa la frase come un printf()
  cin >> temp;    		    // Legge il valore come scanf()
  cane2.mettilungh(temp);	    // Passa a mettilungh la variabile temp
  cout << "Lunghezza millepiedi? "; // Stampa la frase come un printf()
  cin >> temp;    		    // Legge il valore come scanf()
  millepiedi.mettilungh(temp);	    // Passa a mettilungh la variabile temp
  cout << "Num. esatto piedi del millepiedi? ";  // Stampa la frase.
  cin >> temp2;    		                 // Legge il valore.
  millepiedi.mettizampe(temp2);     // Passa a mettizampe la variabile temp2

// Ora visualizziamo lo stato degli animali, usando i loro metodi di lettura.

  cout << "\nStato del cane1: zampe = " << cane1.leggizampe();
  cout << ", lunghezza = " << cane1.leggilungh();
  cout << "\nStato del cane2: zampe = " << cane2.leggizampe();
  cout << ", lunghezza = " << cane2.leggilungh();
  cout << "\nStato del millepiedi: zampe = " << millepiedi.leggizampe();
  cout << ", lunghezza = " << millepiedi.leggilungh() << "\n";

  return 0;	// main() restituisce 0
}

/* I costruttori e i distruttori, comunque, sono facoltativi, non sempre
 * sono indispensabili.
 */