/* Purtroppo i vari C++ non sono tutti uguali, specialmente per quanto
* riguarda le librerie di classi. Veniamo comunque alla pratica.
* Una classe si dichiara in modo simile ad una struttura, e ha delle
* aree di sicurezza per le sue variabili e funzioni: PRIVATE, quella a
* cui si puo' accedere solo dalla classe stessa, PROTECTED, quella a cui
* possono accedere anche le classi derivate, oltre alla propria, e PUBLIC,
* che puo' essere raggiunta da tutte le funzioni del programma.
* La sintassi generale di una dichiarazione di classe e' la seguente:
*
* class nome_classe {
* dati e funzioni private
* public:
* dati e funzioni pubbliche
* } eventuale lista oggetti da creare;
*
* Vediamo una classe minima:
*
* class animale { // Definisco la classe animale
* int sonofattimiei; // Questa parte e' PRIVATE di default
* public: // La parte che segue e' PUBLIC (visibile da tutti)
* float lunghezza; // Nota: non si dovrebbero mai mettere delle
* int numerozampe; // variabili in un area public. Non lo faremo piu'
* };
*
* Abbiamo anche introdotto il nuovo tipo di commento ad una sola linea,
* che inizia dal // e termina alla fine della riga, senza bisogno di
* richiuderlo, a differenza del vecchio che va richiuso. I due tipi di
* commento si possono usare nello stesso listato scegliendo volta per volta
* quale e' piu' opportuno.
* Come si vede dal commento, non e' buona regola per la OOP mettere
* variabili in area public, ossia renderle accessibili dall'esterno.
* Ora possiamo dichiarare alcuni oggetti di tipo animale e usarli:
*
* animale cane1,cane2,gatto; // istanziamo 3 oggetti di tipo "animale".
*
* cane1.lunghezza = 30; // Accediamo alle variabili pubbliche
* cane1.numerozampe = 4; // dell'oggetto da qualsiasi parte del prog.
*
* Come si nota, abbiamo usato l'operatore "." per dividere il nome
* dell'oggetto dal nome della sua variabile, analogamente a come si fa
* per le strutture. Da notare che ogni oggetto creato dalla classe astratta
* "animale" e' indipendente, per cui scrivere in cane1.lunghezza non
* modifica cane2.lunghezza, trattandosi di 2 oggetti fisicamente distinti:
* il solo rapporto esistente tra cane1,cane2 e gatto e' che sono oggetti
* dello stesso tipo.
* Ora vedremo questo esempio, ma prima occorre introdurre CIN e COUT, le
* nuove funzioni di Input/Output del C++, che si trovano in iostream.h.
* Ecco un esempio del loro uso:
*
* #include <iostream.h> // Header necessario per usare CIN e COUT
* // Questo e' un commento C++ ad una sola linea
* int i; // Definisco una variabile intera
* char str[80]; // Definisco una stringa
*
* main(void)
* {
* cout << "Introdurre un numero: "; // Stampa la frase come un printf()
* cin >> i; // Legge il valore e lo copia in i come scanf()
* cout << "Introdurre una stringa: ";
* cin >> str; // Legge la stringa copiandola in str
*
* cout << "Il numero introdotto e': " << i << "\n";
* cout << "La stringa introdotta e': " << str << "\n";
*
* }
*
* Come si puo' notare, con CIN e COUT si possono trattare allo stesso
* modo stringhe, int, float, senza preoccuparci di specificare il tipo e
* il numero di caratteri da stampare, a differenza di printf e scanf.
* L'operatore << normalmente significa "scorrimento a sinistra dei bit",
* ma quando e' usato in questo modo e' un operatore di output.
* Lo stesso vale per >>, che e' lo scorrimento a destra, a parte questi
* casi in cui indica l'input da tastiera.
* Da notare che in C++ e' sempre possibile usare printf() e scanf().
* Ora siamo in grado di scrivere il primo programmino.
*/
#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
int sonofattimiei; // Questa parte e' PRIVATE di default
public: // La parte che segue e' PUBLIC (visibile da tutti)
float lunghezza; // Nota: non si dovrebbero mai mettere delle
int numerozampe; // variabili in un area public. Non lo faremo piu'
};
main(void)
{
// Ora possiamo dichiarare alcuni oggetti di tipo animale e usarli:
animale cane1,cane2,millepiedi; // Ecco che istanzio 3 animali...
// ossia creo 3 esemplari.
cane1.numerozampe = 4; // Accediamo alle variabili pubbliche
cane2.numerozampe = 4; // dell'oggetto analogamente a come
millepiedi.numerozampe = 1000; // accediamo a dati delle strutture.
// Richiediamo dati dall'utente.
cout << "Lunghezza cane 1? "; // Stampa la frase come un printf()
cin >> cane1.lunghezza; // Legge il valore come scanf()
cout << "Lunghezza cane 2? "; // Stampa la frase come un printf()
cin >> cane2.lunghezza; // Legge il valore come scanf()
cout << "Lunghezza millepiedi? "; // Stampa la frase come un printf()
cin >> millepiedi.lunghezza; // Legge il valore come scanf()
cout << "Num. esatto piedi del millepiedi? "; // Stampa la frase.
cin >> millepiedi.numerozampe; // Legge il valore come scanf()
// Visualiziamo lo stato degli animali.
cout << "\nStato del cane1: zampe = " << cane1.numerozampe;
cout << ", lunghezza = " << cane1.lunghezza;
cout << "\nStato del cane2: zampe = " << cane2.numerozampe;
cout << ", lunghezza = " << cane2.lunghezza;
cout << "\nStato del millepiedi: zampe = " << millepiedi.numerozampe;
cout << ", lunghezza = " << millepiedi.lunghezza << "\n";
}
/* Da notare che abbiamo agito su int e float senza fare distinzioni, usando
* sempre CIN e COUT. In questo esempio abbiamo definito una variabile
* "sonofattimiei", privata, che non e' stata usata, dato che la classe
* non ha funzioni (metodi), gli unici che avrebbero potuto accederci.
* Invece abbiamo scritto da "fuori" l'oggetto nelle due variabili pubbliche
* "lunghezza" e "numerozampe". Non e' certo molto Object Oriented...
* Cio' limita la classe ad una sorta di normale struttura, ed e' contrario
* ai principi della OOP, in quanto si dovrebbero limitare, o evitare del
* tutto variabili pubbliche, rendendo privati tutti i dati, controllandone
* l'accesso mediante funzioni pubbliche. Piu' avanti avremo una maggiore
* eleganza OOP.
*/