Esercitazioni LPS: differenze tra le versioni

// questo è un commento a linea singola in puro stile C++

// la programmazione ad oggetti supporta //

// l'incapsulamento

// il polimorfismo

// l'ereditarietà 

// esempio di incapsulamento: dati e funzioni in un oggetto

// esempio di polimorfismo a compile time: overloading di funzioni

// esempio di ereditarietà: classe persona e classe studente

// esempio di costruttore per inizializzare variabili a valori di default

// un oggetto è una istanza di una classe

// include la necessaria intestazione <iostream>

#include <iostream>

// l'istruzione using informa il compilatore che intende utilizzare il namespace standard

using namespace std;

// i namespace creano delle regioni di dichiarazione

// nel namespace standard viene dichiarata l'intera libreria standard del C++

// Creazione della classe persona

// una classe può contenere attributi (variabili) e metodi (funzioni) privati, protetti e pubblici

// per ora prevediamo soltanto attributi privati e metodi pubblici

class persona {

private: //private è pleonastico (si può omettere)

	int IDP;

	// IDP in quanto variabile privata non risulta visibile da funzioni che non siano metodi della classe persona

public:

	void leggiIDP();

	void leggiIDP(int);

	void stampaIDP();

// segue la funzione costruttore, omonima della classe, e nella cui dichiarazione non si specifica il valore restituito

	persona();

// segue la funzione costruttore overloadata con un parametro

	persona(int);

// segue la funzione distruttore, omonima della classe ma preceduta dal TILDE, e nella cui dichiarazione non si specifica il valore restituito

        ~persona();

};

class studente : public persona {

private:

	int IDS;

public:

	void leggiIDS();

	void stampaIPDS();

	studente();

        ~studente();

};

void persona::leggiIDP()

{

        cin >> IDP;

}

void persona::leggiIDP(int A)

{

	IDP = A;

}

void persona::stampaIDP()

{

	cout << IDP << endl;

	// endl per andare a capo

}

persona::persona()

{

        cout << "Persona costruita " << endl;

	IDP = 0;

}

persona::persona(int A)

{

        cout << "Persona costruita con parametro passato per valore " << endl;

	IDP = A;

}

persona::~persona()

{

        cout << "Persona distrutta " << endl;

}

studente::studente()

{

        cout << "Studente costruito " << endl;

	IDS = 0;

}

studente::~studente()

{

        cout << "Studente distrutto " << endl;

}

void studente::leggiIDS()

{

	cin >> IDS;

}

void studente::stampaIPDS()

{

	cout << "Identificativo studente pari a " << IDS << endl;

}

// verificare il sorgente modificato ...

int main()

{

	persona P, Q(3);

	studente S; // verifica della chiamata del costruttore di persona senza parametri

	// P.IDP=2; errore cannot access private member

	P.stampaIDP();

	P.leggiIDP();

	P.stampaIDP();

        Q.stampaIDP();

	Q.leggiIDP(2);

	Q.stampaIDP();

	S.leggiIDP();

	S.stampaIDP();

	S.leggiIDS();

	S.stampaIPDS();

	// Decommentare su visual studio

	// system("pause");

	return 0;

}

#include <iostream>

using namespace std;

class Base 

{

public:

	virtual void stampa() {

		cout << "Metodo stampa della classe Base" << endl;

	}

};

class DerivataUno : public Base 

{

public:

	void stampa() {

		cout << "Metodo stampa della classe Derivata1" << endl;

	}

};

class DerivataDue : public Base

{

public:

	void funzione() {

		cout << "Funzione specifica della classe DerivataDue" << endl;

	}

};

int main()

{

	Base b, *p;

	DerivataUno d1;

	DerivataDue d2;

	p = &b;

	// Richiamata la funzione stampa della classe Base

	p->stampa();

	p = &d1;

	// Richiamata la funzione stampa della classe DerivataUno

	p->stampa();

	p = &d2;

	// Richiamata la funzione stampa della classe Base

	p->stampa();

	// Richiama il metodo specifico della classe DerivataDue ->

	// -> cast a punatatore di tipo classe derivata

	((DerivataDue*)p)->funzione();

	system("pause");

}

#include <iostream>

using namespace std;

int main()

{

}