Esercitazioni LPS: differenze tra le versioni

Da Bioingegneria Elettronica e Informatica.
Riga 301: Riga 301:
  
  
−
== Esempio di costruttore di copia di un vettore==
+
== Esempio di Costruttore di copia di un vettore ==
 
<syntaxhighlight lang="cpp" line>
 
<syntaxhighlight lang="cpp" line>
 
#include <iostream>
 
#include <iostream>
Riga 385: Riga 385:
 
distruzione
 
distruzione
 
Press any key to continue
 
Press any key to continue
 +
*/
 +
</syntaxhighlight>
 +
 +
== Esempio di Costruttore di copia di una matrice ==
 +
<syntaxhighlight lang="cpp" line>
 +
#include <iostream>
 +
#include <new>
 +
#include <cstdlib>
 +
using namespace std;
 +
 +
// ATTENZIONE: in ambiente Visual Studio avviare senza eseguire Debug (CTRL+F5)
 +
 +
// Terzo esempio per creare costruttori di copie
 +
// N.B. quando si esegue una copia i due oggetti sono identici bit a bit,
 +
// quando però la inizializzazione comporta l'allocazione di memoria non deve
 +
// essere fatta una copia bit a bit
 +
 +
// Questo programma crea una classe per array bidimensionali "sicuri"
 +
 +
 +
class matrice
 +
{
 +
int **p;
 +
int dimRighe;
 +
int dimColonne;
 +
public:
 +
matrice(int r, int c)
 +
{
 +
cout << "Costruzione matrice e inizializzazione degli elementi a zero" << endl;
 +
dimRighe = r;
 +
dimColonne = c;
 +
 +
p = new int *[r];
 +
 +
for (int i = 0; i < dimRighe; i++) {
 +
p[i] = new int[dimColonne];
 +
}
 +
 +
int i, j;
 +
for (i = 0; i < dimRighe; i++) {
 +
for (j = 0; j < dimColonne; j++) {
 +
p[i][j] = 0;
 +
}
 +
}
 +
 +
 +
cout << endl;
 +
}
 +
 +
~matrice() {
 +
for (int i = 0; i < dimRighe; i++) {
 +
delete[] p[i];
 +
}
 +
delete[] p;
 +
cout << "Distruzione della matrice creata nel main alla fine del main" << endl;
 +
}
 +
 +
// costruttore di copie
 +
matrice(const matrice &mat);
 +
 +
void stampa() {
 +
cout << "Stampa elementi matrice: " << endl;
 +
int i, j;
 +
for (i = 0; i < dimRighe; i++) {
 +
cout << endl;
 +
for (j = 0; j < dimColonne; j++) {
 +
cout << p[i][j];
 +
}
 +
}
 +
 +
cout << endl << endl;
 +
}
 +
 +
void modificaMatrice() {
 +
cout << "Modifica elementi matrice ( +1 ): " << endl;
 +
int i, j;
 +
for (i = 0; i < dimRighe; i++) {
 +
for (j = 0; j < dimColonne; j++) {
 +
p[i][j] = p[i][j] + 1;
 +
}
 +
}
 +
cout << endl;
 +
}
 +
 +
};
 +
 +
// Costruttore di copie
 +
matrice::matrice(const matrice &mat)
 +
{
 +
cout << "Costruttore di copie della matrice" << endl;
 +
dimRighe = mat.dimRighe;
 +
dimColonne = mat.dimColonne;
 +
 +
p = new int *[dimRighe];
 +
for (int i = 0; i < dimRighe; i++) {
 +
p[i] = new int[dimColonne];
 +
}
 +
 +
int i, j;
 +
for (i = 0; i < dimRighe; i++) {
 +
for (j = 0; j < dimColonne; j++) {
 +
p[i][j] = mat.p[i][j];
 +
}
 +
}
 +
 +
cout << endl;
 +
}
 +
 +
int main()
 +
{
 +
 +
matrice m1(2,3);
 +
m1.stampa();
 +
 +
matrice m2(m1);
 +
m2.stampa();
 +
 +
m1.modificaMatrice();
 +
m1.stampa();
 +
 +
return 0;
 +
}
 +
 +
/*
 +
Costruzione matrice e inizializzazione degli elementi a zero
 +
 +
Stampa elementi matrice:
 +
 +
000
 +
000
 +
 +
Costruttore di copie della matrice
 +
 +
Stampa elementi matrice:
 +
 +
000
 +
000
 +
 +
Modifica elementi matrice ( +1 ):
 +
 +
Stampa elementi matrice:
 +
 +
111
 +
111
 +
 +
Distruzione della matrice creata nel main alla fine del main
 +
Distruzione della matrice creata nel main alla fine del main
 +
Premere un tasto per continuare . . .
 +
 
*/
 
*/
 
</syntaxhighlight>
 
</syntaxhighlight>

Versione delle 14:58, 29 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

  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 DerivataUno" << 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. }

Funzioni virtuali pure e Classi Astratte

  1. #include <iostream>
  2. #include <cmath>
  3.  
  4. using namespace std;
  5.  
  6. class Figura
  7. {
  8. 	// Classe Astratta: contiene almeno una funzione virtuale pura
  9. protected:
  10. 	double perimetro;
  11. 	double area;
  12. public:
  13. 	Figura() { perimetro = 0; area = 0; }
  14.  
  15. 	virtual void calcolaPerimetro() = 0; // Funzione virtuale pura
  16. 	virtual void calcolaArea() = 0; // Necessario ridefinire i metodi virtuali puri nelle classi derivati, altrimenti errore in compilazione
  17. };
  18.  
  19. class Triangolo : public Figura
  20. {
  21. private:
  22. 	// Dimensione dei tre lati
  23. 	double l1, l2, l3;
  24. public:
  25. 	Triangolo(double L1, double L2, double L3) {
  26. 		l1 = L1; l2 = L2; l3 = L3;
  27. 	}
  28.  
  29. 	void calcolaPerimetro() {
  30. 		perimetro = l1 + l2 + l3;
  31. 		cout << "Il perimetro del Triangolo con lati " << 
  32. 			l1 << " " << l2 << " e " << l3 << " vale: " << perimetro << endl;
  33. 	}
  34.  
  35. 	// Calcolo area con formula di Erone
  36. 	void calcolaArea() { 
  37. 		double p = (l1 + l2 + l3) / 2;
  38. 		area = sqrt(p*(p - l1)*(p - l2)*(p - l3));
  39. 		cout << "L'area del Triangolo con lati " <<
  40. 			l1 << " " << l2 << " e " << l3 << " vale: " << area << endl;
  41. 	}
  42. };
  43.  
  44. class Rettangolo : public Figura
  45. {
  46. private:
  47. 	// Dimensione di base e altezza
  48. 	double l1, l2;
  49. public:
  50. 	Rettangolo(double L1, double L2) {
  51. 		l1 = L1; l2 = L2;
  52. 	}
  53. 	void calcolaPerimetro() {
  54. 		perimetro = 2*(l1 + l2);
  55. 		cout << "Il perimetro del Rettangolo con lati " << l1 << " e " << l2 << " vale: " << perimetro << endl;
  56. 	}
  57.  
  58. 	void calcolaArea() {
  59. 		area = l1 * l2;
  60. 		cout << "L'area del Rettangolo con lati " << l1 << " e " << l2 << " vale: " << area << endl;
  61. 	}
  62. };
  63.  
  64. class Cerchio : public Figura
  65. {
  66. private:
  67. 	// Dimensione del raggio
  68. 	double l1;
  69. public:
  70. 	Cerchio(double L1) {
  71. 		l1 = L1;
  72. 	}
  73. 	void calcolaPerimetro() {
  74. 		perimetro = 3.14 * 2 * l1;
  75. 		cout << "La circonferenza del cerchio con raggio " << l1 << " vale: " << perimetro << endl;
  76. 	}
  77.  
  78. 	void calcolaArea() {
  79. 		area = 3.14 * l1 * l1;
  80. 		cout << "L'area del cerchio con raggio " << l1 << " vale: " << area << endl;
  81. 	}
  82. };
  83.  
  84.  
  85. int main()
  86. {
  87. 	Figura f; // Errore: non è consentito istanziare oggetti di tipo classe astratta
  88. 	Figura *f1;
  89. 	Triangolo t1(10.3, 9, 18.3);
  90. 	Rettangolo r1(10, 3.5);
  91. 	Cerchio c1(10);
  92.  
  93.  
  94. 	f1 = &t1;
  95. 	f1->calcolaPerimetro();
  96. 	f1->calcolaArea();
  97.  
  98. 	f1 = &r1;
  99. 	f1->calcolaPerimetro();
  100. 	f1->calcolaArea();
  101.  
  102. 	f1 = &c1;
  103. 	f1->calcolaPerimetro();
  104. 	f1->calcolaArea();
  105.  
  106. 	system("pause");
  107. 	return 0;
  108. }


Esempio di Costruttore di copia di un vettore

  1. #include <iostream>
  2. #include <new>
  3. #include <cstdlib>
  4. using namespace std;
  5.  
  6. // ATTENZIONE: in ambiente Visual Studio avviare senza eseguire Debug (CTRL+F5)
  7.  
  8. // Terzo esempio per creare costruttori di copie
  9. // N.B. quando si esegue una copia i due oggetti sono identici bit a bit,
  10. // quando però la inizializzazione comporta l'allocazione di memoria non deve
  11. // essere fatta una copia bit a bit 
  12.  
  13. // Questo programma crea una classe per array "sicuri"
  14.  
  15.  
  16. class vettore
  17. {
  18. 	int *p;
  19. 	int dimensione;
  20. public:
  21. 	vettore(int dim)
  22. 	{
  23. 		cout << "costruzione" << endl;
  24. 		p = new int[dim];
  25. 		dimensione = dim;
  26. 	}
  27.  
  28. 	~vettore() { delete[] p; cout << "distruzione" << endl; }
  29. 	// costruttore di copie
  30. 	vettore(const vettore &vett);
  31.  
  32. 	void imposta(int i, int j)
  33. 	{
  34. 		if (i >= 0 && i <dimensione)
  35. 			p[i] = j;
  36. 	}
  37.  
  38. 	int prendi(int i)
  39. 	{
  40. 		return p[i];
  41. 	}
  42. };
  43.  
  44. // Costruttore di copie
  45.  
  46. vettore::vettore(const vettore &vett)
  47. {
  48. 	int i;
  49. 	p = new int[vett.dimensione];
  50. 	cout << "costruttore di copie" << endl;
  51. 	for (i = 0; i<vett.dimensione; i++)
  52. 		p[i] = vett.p[i];
  53. }
  54.  
  55.  
  56. int main()
  57. {
  58. 	vettore num(10);
  59. 	int i;
  60. 	for (i = 0; i<10; i++) num.imposta(i, i);
  61. 	for (i = 9; i >= 0; i--) cout << num.prendi(i);
  62. 	cout << "\n";
  63.  
  64. 	// i vettori num e x contengono gli stessi valori ma ciascun vettore
  65. 	// si trova in aree diverse di memoria
  66.  
  67. 	// crea un altro vettore e lo inizializza con num
  68. 	vettore x(num); // richiama il costruttore di copie;
  69. 	for (i = 0; i<10; i++) cout << num.prendi(i);
  70. 	cout << "\nciao\n";
  71. 	return 0;
  72. }
  73.  
  74. /*
  75. costruzione
  76. 9876543210
  77. costruttore di copie
  78. 0123456789
  79. ciao
  80. distruzione
  81. distruzione
  82. Press any key to continue
  83. */

Esempio di Costruttore di copia di una matrice

  1. #include <iostream>
  2. #include <new>
  3. #include <cstdlib>
  4. using namespace std;
  5.  
  6. // ATTENZIONE: in ambiente Visual Studio avviare senza eseguire Debug (CTRL+F5)
  7.  
  8. // Terzo esempio per creare costruttori di copie
  9. // N.B. quando si esegue una copia i due oggetti sono identici bit a bit,
  10. // quando però la inizializzazione comporta l'allocazione di memoria non deve
  11. // essere fatta una copia bit a bit 
  12.  
  13. // Questo programma crea una classe per array bidimensionali "sicuri"
  14.  
  15.  
  16. class matrice
  17. {
  18. 	int **p;
  19. 	int dimRighe;
  20. 	int dimColonne;
  21. public:
  22. 	matrice(int r, int c)
  23. 	{
  24. 		cout << "Costruzione matrice e inizializzazione degli elementi a zero" << endl;
  25. 		dimRighe = r;
  26. 		dimColonne = c;
  27.  
  28. 		p = new int *[r];
  29.  
  30. 		for (int i = 0; i < dimRighe; i++) {
  31. 			p[i] = new int[dimColonne];
  32. 		}
  33.  
  34. 		int i, j;
  35. 		for (i = 0; i < dimRighe; i++) {
  36. 			for (j = 0; j < dimColonne; j++) {
  37. 				p[i][j] = 0;
  38. 			}
  39. 		}
  40.  
  41.  
  42. 		cout << endl;
  43. 	}
  44.  
  45. 	~matrice() { 
  46. 		for (int i = 0; i < dimRighe; i++) {
  47. 			delete[] p[i];
  48. 		}
  49. 		delete[] p;
  50. 		cout << "Distruzione della matrice creata nel main alla fine del main" << endl;
  51. 	}
  52.  
  53. 	// costruttore di copie
  54. 	matrice(const matrice &mat);
  55.  
  56. 	void stampa() {
  57. 		cout << "Stampa elementi matrice: " << endl;
  58. 		int i, j;
  59. 		for (i = 0; i < dimRighe; i++) {
  60. 			cout << endl;
  61. 			for (j = 0; j < dimColonne; j++) {
  62. 				cout << p[i][j];
  63. 			}
  64. 		}
  65.  
  66. 		cout << endl << endl;
  67. 	}
  68.  
  69. 	void modificaMatrice() {
  70. 		cout << "Modifica elementi matrice ( +1 ): " << endl;
  71. 		int i, j;
  72. 		for (i = 0; i < dimRighe; i++) {
  73. 			for (j = 0; j < dimColonne; j++) {
  74. 				p[i][j] = p[i][j] + 1;
  75. 			}
  76. 		}
  77. 		cout << endl;
  78. 	}
  79.  
  80. };
  81.  
  82. // Costruttore di copie
  83. matrice::matrice(const matrice &mat)
  84. {
  85. 	cout << "Costruttore di copie della matrice" << endl;
  86. 	dimRighe = mat.dimRighe;
  87. 	dimColonne = mat.dimColonne;
  88.  
  89. 	p = new int *[dimRighe];
  90. 	for (int i = 0; i < dimRighe; i++) {
  91. 		p[i] = new int[dimColonne];
  92. 	}
  93.  
  94. 	int i, j;
  95. 	for (i = 0; i < dimRighe; i++) {
  96. 		for (j = 0; j < dimColonne; j++) {
  97. 			p[i][j] = mat.p[i][j];
  98. 		}
  99. 	}
  100.  
  101. 	cout << endl;
  102. }
  103.  
  104. int main()
  105. {
  106.  
  107. 	matrice m1(2,3);
  108. 	m1.stampa();
  109.  
  110. 	matrice m2(m1);
  111. 	m2.stampa();
  112.  
  113. 	m1.modificaMatrice();
  114. 	m1.stampa();
  115.  
  116. 	return 0;
  117. }
  118.  
  119. /*
  120. Costruzione matrice e inizializzazione degli elementi a zero
  121.  
  122. Stampa elementi matrice:
  123.  
  124. 000
  125. 000
  126.  
  127. Costruttore di copie della matrice
  128.  
  129. Stampa elementi matrice:
  130.  
  131. 000
  132. 000
  133.  
  134. Modifica elementi matrice ( +1 ):
  135.  
  136. Stampa elementi matrice:
  137.  
  138. 111
  139. 111
  140.  
  141. Distruzione della matrice creata nel main alla fine del main
  142. Distruzione della matrice creata nel main alla fine del main
  143. Premere un tasto per continuare . . .
  144.  
  145. */
Estratto da "http://www.vitoantoniobevilacqua.it/wiki/index.php?title=Esercitazioni_LPS&oldid=962"