fine lezione 14

14_array_statici.md

@@ -39,3 +39,44 @@ Gli array dinamici vengono allocati nell'heap (come vedremo più avanti)
 Hint: usa il flag `--pedantic-error` per evitare che il compilatore non permetta di definire VLA
 
 [stampa_array.cpp](./esercitazioni/stampa_array.cpp)
+[array_casuali.cpp](./esercitazioni/array_casuali.cpp)
+
+## Dimensione
+Nel caso di un array di char, ogni locazione di memoria ha dimensione 1 byte, equivalente alla dimensione di una cella => dimensione array in memoria = numero elementi
+
+Nel caso di un int: dim array in memoria = 4\*num elementi
+
+## Copia array
+L'unico modo di copiare un array in un altro array è quello di utilizzare un ciclo che esegua la copia posto per posto.
+
+## Vettori e array
+I due termini sono interscambiabili, perchè l'array è la rappresentazione i memoria di un vettore matematico
+
+
+[max_of_array.cpp](./esercitazioni/max_of_array.cpp)
+[max_of_array_index.cpp](./esercitazioni/max_of_array_index.cpp)
+
+## Dimensione array
+Posso ottenere la dimensione in byte di un array con `sizeof(v)`
+Per calcolare il numero di celle dell'array divido questo valore per la dimensione del tipo di dato memorizzato in `v`: `sizeof(v)/<tipe_of_v>`
+
+## Mancanza di controllo degli indici
+A tempo di esecuzione non viene vietato di accedere ad aree di memoria esterne all'array stesso.
+=> injection, buffer overflow e le "peggiocose" sono possibili a causa della mancanza di controlli
+
+## Inizializzazione
+`[const] <tipo> <nome> [<dim_const>] = {<ele1>, <ele2>, ...};`
+
+Un array che viene definito come costante deve essere inizializzato all'inizio del programma.
+
+## Array come argomenti
+`<dichiarazione_parametro_formale> ::= [const] <tipo> <identificatore> []`
+
+Gli array sono passati automaticamente per riferimento, mai per copia. Quindi all'interno della funzione posso sempre modificare i valori contenuti in esso, a meno che non utilizzi il modificatore `const`
+
+Le informazioni sulla dimensione dell'array non vengono passate alla funzione, è il programmatore che se ne deve occupare: var globale oppure costante globale (consigliata la prima soluzione).
+
+
+[calcola_somma.cpp](./esercitazioni/calcola_somma.cpp)
+[raddoppia_array.cpp](./esercitazioni/raddoppia_array.cpp)
+[pari_array.cpp](./esercitazioni/pari_array.cpp)

esercitazioni/array_casuali.cpp

@@ -0,0 +1,18 @@
+#include <iostream>
+#include <time.h>
+
+using namespace std;
+
+int main() {
+	srand(time(0));
+	const int dim = 5;
+	int v[dim];	
+
+	for (int i=0; i<dim; i++) {
+		v[i] = rand();
+	}
+
+	for (int i=0; i<dim; i++) {
+		cout << v[i] << endl;
+	}
+}

esercitazioni/calcola_somma.cpp

@@ -0,0 +1,34 @@
+#include <iostream>
+#include <time.h>
+
+using namespace std;
+
+const int somma(const int[], const int);
+inline const int rand_in_range(const int, const int);
+
+int main() {
+	const int DIM = 5;
+	const int RANGE_INF = 0, RANGE_SUP = 10;
+	int v[DIM];
+
+	srand(time(0));
+
+	for (int i=0; i<DIM; i++) { // scorri in modo crescente per sfruttare cache line
+			v[i] = rand_in_range(RANGE_INF, RANGE_SUP);
+			cout << v[i] << endl;
+	}
+
+	cout << endl << somma(v, DIM) << endl;
+}
+
+const int somma(const int v[], const int dim) {
+	int somma = 0;
+	for (int i=0; i<dim; i++) {
+		somma += v[i];
+	}
+	return somma;
+}
+
+inline const int rand_in_range(const int inf, const int sup) {
+	return rand()%(sup-inf+1) + inf;
+}

esercitazioni/max_of_array.cpp

@@ -0,0 +1,36 @@
+#include <iostream>
+#include <time.h>
+
+using namespace std;
+
+inline int max(const int a, const int b);
+inline int rand_in_range(const int inf, const int sup);
+
+int main() {
+	srand(time(0));
+	const int dim = 5;
+	int v[dim];	
+
+	// generazione e stampa
+	for (int i=0; i<dim; i++) {
+		v[i] = rand_in_range(1, 100);
+		cout << v[i] << endl;
+	}
+
+	// ricerca massimo
+	int massimo = v[0];
+	for (int i=0; i<dim; i++) {
+		massimo = max(massimo, v[i]);
+	}
+
+	cout << "Il valore massimo presente nel vettore è: " << massimo << endl;
+	return 0;
+}
+
+inline int max(const int a, const int b) {
+	return a > b ? a : b;
+}
+
+inline int rand_in_range(const int inf, const int sup) {
+	return rand()%(sup-inf) + inf;
+}

esercitazioni/max_of_array_index.cpp

@@ -0,0 +1,38 @@
+#include <iostream>
+#include <time.h>
+
+using namespace std;
+
+inline int max(const int a, const int b);
+inline int rand_in_range(const int inf, const int sup);
+
+int main() {
+	srand(time(0));
+	const int dim = 5;
+	int v[dim];	
+
+	// generazione e stampa
+	for (int i=0; i<dim; i++) {
+		v[i] = rand_in_range(1, 100);
+		cout << v[i] << endl;
+	}
+
+	// ricerca massimo
+	int index = 0;
+	for (int i=0; i<dim; i++) {
+		if (v[index] < v[i]) {
+			index = i;
+		}
+	}
+
+	cout << "Il valore massimo presente nel vettore è: " << v[index] << endl;
+	return 0;
+}
+
+inline int max(const int a, const int b) {
+	return a > b ? a : b;
+}
+
+inline int rand_in_range(const int inf, const int sup) {
+	return rand()%(sup-inf) + inf;
+}

esercitazioni/pari_array.cpp

@@ -0,0 +1,42 @@
+#include <iostream>
+#include <time.h>
+
+using namespace std;
+
+void copia_pari(const int[], const int, int[], int&);
+inline const int rand_in_range(const int, const int);
+
+int main() {
+	const int DIM = 5;
+	const int RANGE_INF = 0, RANGE_SUP = 10;
+	int v[DIM], pari[DIM];
+	int pari_dim = 0;
+
+	srand(time(0));
+
+	for (int i=0; i<DIM; i++) { // scorri in modo crescente per sfruttare cache line
+			v[i] = rand_in_range(RANGE_INF, RANGE_SUP);
+			cout << v[i] << endl;
+	}
+
+	copia_pari(v, DIM, pari, pari_dim);
+
+	cout << endl;
+	for (int i=0; i<pari_dim; i++) {
+		cout << pari[i] << endl;
+	}
+}
+
+// dim_out verrà inizializzato a zero
+// output[] deve avere una dimensione pari o superiore a dim_in
+void copia_pari(const int input[], const int dim_in, int output[], int &dim_out) {
+	dim_out = 0;
+	for (int i=0; i<dim_in; i++) {
+		if (input[i]%2 == 0)
+			output[dim_out++] = input[i];
+	}
+}
+
+inline const int rand_in_range(const int inf, const int sup) {
+	return rand()%(sup-inf+1) + inf;
+}

esercitazioni/raddoppia_array.cpp

@@ -0,0 +1,37 @@
+#include <iostream>
+#include <time.h>
+
+using namespace std;
+
+void raddoppia_array(int[], const int);
+inline const int rand_in_range(const int, const int);
+
+int main() {
+	const int DIM = 5;
+	const int RANGE_INF = 0, RANGE_SUP = 10;
+	int v[DIM];
+
+	srand(time(0));
+
+	for (int i=0; i<DIM; i++) { // scorri in modo crescente per sfruttare cache line
+			v[i] = rand_in_range(RANGE_INF, RANGE_SUP);
+			cout << v[i] << endl;
+	}
+
+	raddoppia_array(v, DIM);
+
+	cout << endl;
+	for (int i=0; i<DIM; i++) {
+		cout << v[i] << endl;
+	}
+}
+
+void raddoppia_array(int v[], const int dim) {
+	for (int i=0; i<dim; i++) {
+		v[i] *= 2;
+	}
+}
+
+inline const int rand_in_range(const int inf, const int sup) {
+	return rand()%(sup-inf+1) + inf;
+}