Esercitazioni LPS: differenze tra le versioni

Da Bioingegneria Elettronica e Informatica.
Riga 129: Riga 129:
 
// system("pause");
 
// system("pause");
 
return 0;
 
return 0;
 +
}
 +
</syntaxhighlight>
 +
 +
== Funzioni virtuali e Classi astratte ==
 +
<syntaxhighlight lang="cpp" line>
 +
#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");
 +
 
}
 
}
 
</syntaxhighlight>
 
</syntaxhighlight>

Versione delle 09:41, 22 mag 2019


Esercitazione del 2 e 15 maggio 2019

  1. // questo è un commento a linea singola in puro stile C++
  2.  
  3.  
  4. // la programmazione ad oggetti supporta //
  5. // l'incapsulamento
  6. // il polimorfismo
  7. // l'ereditarietà 
  8.  
  9. // esempio di incapsulamento: dati e funzioni in un oggetto
  10. // esempio di polimorfismo a compile time: overloading di funzioni
  11. // esempio di ereditarietà: classe persona e classe studente
  12. // esempio di costruttore per inizializzare variabili a valori di default
  13.  
  14.  
  15. // un oggetto è una istanza di una classe
  16.  
  17. // include la necessaria intestazione <iostream>
  18. #include <iostream>
  19.  
  20. // l'istruzione using informa il compilatore che intende utilizzare il namespace standard
  21. using namespace std;
  22. // i namespace creano delle regioni di dichiarazione
  23. // nel namespace standard viene dichiarata l'intera libreria standard del C++
  24.  
  25. // Creazione della classe persona
  26. // una classe può contenere attributi (variabili) e metodi (funzioni) privati, protetti e pubblici
  27. // per ora prevediamo soltanto attributi privati e metodi pubblici
  28. class persona {
  29. private: //private è pleonastico (si può omettere)
  30. 	int IDP;
  31. 	// IDP in quanto variabile privata non risulta visibile da funzioni che non siano metodi della classe persona
  32. public:
  33. 	void leggiIDP();
  34. 	void leggiIDP(int);
  35. 	void stampaIDP();
  36. // segue la funzione costruttore, omonima della classe, e nella cui dichiarazione non si specifica il valore restituito
  37. 	persona();
  38. // segue la funzione costruttore overloadata con un parametro
  39. 	persona(int);
  40. // segue la funzione distruttore, omonima della classe ma preceduta dal TILDE, e nella cui dichiarazione non si specifica il valore restituito
  41.         ~persona();
  42. };
  43.  
  44. class studente : public persona {
  45. private:
  46. 	int IDS;
  47. public:
  48. 	void leggiIDS();
  49. 	void stampaIPDS();
  50. 	studente();
  51.         ~studente();
  52. };
  53.  
  54. void persona::leggiIDP()
  55. {
  56.         cin >> IDP;
  57. }
  58. void persona::leggiIDP(int A)
  59. {
  60. 	IDP = A;
  61. }
  62. void persona::stampaIDP()
  63. {
  64. 	cout << IDP << endl;
  65. 	// endl per andare a capo
  66. }
  67.  
  68. persona::persona()
  69. {
  70.         cout << "Persona costruita " << endl;
  71. 	IDP = 0;
  72. }
  73.  
  74. persona::persona(int A)
  75. {
  76.         cout << "Persona costruita con parametro passato per valore " << endl;
  77. 	IDP = A;
  78. }
  79.  
  80. persona::~persona()
  81. {
  82.         cout << "Persona distrutta " << endl;
  83. }
  84.  
  85. studente::studente()
  86. {
  87.         cout << "Studente costruito " << endl;
  88. 	IDS = 0;
  89. }
  90.  
  91. studente::~studente()
  92. {
  93.         cout << "Studente distrutto " << endl;
  94. }
  95. void studente::leggiIDS()
  96. {
  97. 	cin >> IDS;
  98. }
  99.  
  100. void studente::stampaIPDS()
  101. {
  102. 	cout << "Identificativo studente pari a " << IDS << endl;
  103. }
  104.  
  105. // verificare il sorgente modificato ...
  106.  
  107. int main()
  108. {
  109. 	persona P, Q(3);
  110. 	studente S; // verifica della chiamata del costruttore di persona senza parametri
  111. 	// P.IDP=2; errore cannot access private member
  112. 	P.stampaIDP();
  113. 	P.leggiIDP();
  114. 	P.stampaIDP();
  115.         Q.stampaIDP();
  116. 	Q.leggiIDP(2);
  117. 	Q.stampaIDP();
  118.  
  119. 	S.leggiIDP();
  120. 	S.stampaIDP();
  121. 	S.leggiIDS();
  122. 	S.stampaIPDS();
  123.  
  124. 	// Decommentare su visual studio
  125. 	// system("pause");
  126. 	return 0;
  127. }

Funzioni virtuali e Classi astratte

  1. #include <iostream>
  2.  
  3. using namespace std;
  4.  
  5. class Base 
  6. {
  7. public:
  8. 	virtual void stampa() {
  9. 		cout << "Metodo stampa della classe Base" << endl;
  10. 	}
  11. };
  12.  
  13. class DerivataUno : public Base 
  14. {
  15. public:
  16. 	void stampa() {
  17. 		cout << "Metodo stampa della classe Derivata1" << endl;
  18. 	}
  19. };
  20.  
  21. class DerivataDue : public Base
  22. {
  23. public:
  24. 	void funzione() {
  25. 		cout << "Funzione specifica della classe DerivataDue" << endl;
  26. 	}
  27. };
  28.  
  29. int main()
  30. {
  31. 	Base b, *p;
  32. 	DerivataUno d1;
  33. 	DerivataDue d2;
  34.  
  35. 	p = &b;
  36. 	// Richiamata la funzione stampa della classe Base
  37. 	p->stampa();
  38.  
  39. 	p = &d1;
  40. 	// Richiamata la funzione stampa della classe DerivataUno
  41. 	p->stampa();
  42.  
  43. 	p = &d2;
  44. 	// Richiamata la funzione stampa della classe Base
  45. 	p->stampa();
  46. 	// Richiama il metodo specifico della classe DerivataDue ->
  47. 	// -> cast a punatatore di tipo classe derivata
  48. 	((DerivataDue*)p)->funzione();
  49.  
  50. 	system("pause");
  51.  
  52. }
Estratto da "http://www.vitoantoniobevilacqua.it/wiki/index.php?title=Esercitazioni_LPS&oldid=947"