recupero lezione 6

5_dimensioni_dato.md

@@ -1,12 +1,24 @@
 # Tipi di dato
-## sizeof(<espressione>)
-Ritorna la dimensione di un tipo di dato oppure di un espressione (variabile, espressione numerica, confronto)
 
-TODO: vedi esercizio
+## Operatore sizeof(<espressione>)
+Ritorna la dimensione (in byte) di un tipo di dato oppure di un espressione (dato stesso, variabile, espressione numerica, confronto). Se viene passata un'espressione, la funzione ritorna il numero max di bytes, e di conseguenza di `char`, necessari per memorizzare tutti i possibili valori dell'espressione stessa.
+
+### Dimensione interi
+Dato che la dimensione di un tipo di dato è platform-dependent, d'ora in poi ragioneremo sui risultati ottenuti dalla nostra (mia) macchina. `sizeof(int) == 4`, per cui un interno è memorizzato su 4\*8=32 bit di memoria. Il tipo di dato `int` potrà quindi contenere i valori nell'intervallo [-2^(8\*4-1), 2^(8\*4-1)-1] = [-2147483648, 2147483647]
+
+TODO: vedi esercizio numero bytes oggetto int
 
 ## Overflow
-=> se accettiamo valori più grossi di quelli consentiti
+=> se superiamo i valori limite. Viene chiamato *overflow* se si supera il limite superiore, *underflow* altrimenti.
+
+Quando il risultato di un'espressione è troppo grande o troppo piccolo per essere contenuto nel tipo di dato del risultato (o nell'oggetto a cui si vuole assegnare tale valore). Non vengono sollevati errori (overflow flag ALU (?)) dal SO, quindi il processo non viene abortito; si va però incontro ad un errore logico, in quanto il risultato dell'espressione non è correlato con l'operazione effettuata.
 
-Quando il valore di un espressione è troppo grande per essere contenuto. No errori.
+Eg: `i=2147483647; i++; i == -2147483648`
+Perchè (*in questo caso*) il dato è rappresentato come segue: <1 bit segno><8\*n-1 bit valore (assoluto)>. Dal test precedente possiamo dedurre che `n` vale 4 byte.
 
+### Check
+Supponendo l'operazione `int a, b; int x = a+b`, la variabile x andrà in:
+- *overflow* se _INT_MAX-b<a_
+- *underflow* se _INT_MIN-b>a_
 
+TODO: link esercizio check overflow di somma e moltiplicazione

5_fasi_sviluppo.md

@@ -1,6 +1,12 @@
 # Fasi sviluppo
+
 ## Attori
-Programmatore, compilatore, utente (utonto)
+Programmatore, compilatore, programma e utente (utonto :)
+
+## Tempi del programma
+Lo sviluppo di un programma può essere suddiviso in 3 momenti diversi:
+1. tempo di scrittura (da parte del programmatore). Eg: vengono inizializzate variabili e costanti.
+2. tempo di compilazione. Eg: il compilatore segnala errori di sintassi.
+3. tempo di esecuzione. Eg: l'utente agisce sul processo.
 
-## Fasi
 

6_for.md

@@ -0,0 +1,32 @@
+# Costrutto for
+Perchè introdurlo? è un'istruzione iterativa molto più espressiva di _while_ e _do ... while_, perchè riunisce in un unico posto la condizione, l'inizializzazione dell'indice e la sua modifica.
+
+Infatti, ai costrutti _while_ e _do ... while_ manca un punto espliciti in cui inizializzare le variabili e un punto esplicito in cui inserire l'istruzione di modifica (all'interno dell'intestazione è presente solo la condizione).
+
+## Sintassi
+<istruzione-for> ::=
+	for(<init>; <cond>; <istr_dopo_iter>)  // Intestazione del ciclo for
+		<istruzione_corpo>
+
+Dato che il linguaggio C++ permette la definizione di variabili in qualsiasi punto del main, può essere inserita un'istruzione di definizione come istruzione iniziale del costrutto for. L'ambito di visibilità della variabile si riduce al solo corpo del ciclo (insieme all'intestazione). Il tempo di vita della variabile coincide con la durata del ciclo.
+
+## Espressioni composte
+Richiedono l'utilizzo dell'espressione virgola (`,`)
+
+Date le espressioni <espr1>, <espr2>, ..., <esprN> si può ottenere una _espressione composta_ concatenandole con l'operatore virgola: `<e1>, <e2>, ..., <eN>`. Le espressioni verranno valutate in maniera sequenziale e il valore dell'espressione composta sarà uguale a quello dell'ultima espressione valutata.
+
+TODO: add esercizio della somma dei primi N numeri naturali
+
+## Omissione istruzioni
+Tutte le istruzioni presenti nell'intestazione del costrutto for possono essere omesse. Se manca la condizione, la si assume sempre vera.
+
+## Cicli annidati
+=> ciclo contenuto in un altro ciclo. Funziona con while, do ... while e for
+
+TODO: link esercizi cicli annidati (da quadrato pieno)
+
+## Modifica esecuzione iterazioni
+Il *break* permette di uscire immediatamente da un ciclo. Il break fornisce un exit point dal ciclo (oltre alla valutazione della condizione); la maggiore flessibilità del programma potrebbe aumentarne la difficoltà, oltre a "violare" lo schema della programmazione strutturata (verso la logica spaghetti).
+
+Il *continue* è utilizzabile solo in un ciclo e permette di saltare all'iterazione successiva.
+

6_istruzione_vuota.md

@@ -0,0 +1,2 @@
+# Istruzione vuota
+Corrisponde al `;` ed equivale ad un _nop_, quindi non esegue nulla. Torna spesso utile nel corpo del ciclo for, perché spesso è utile la sola intestazione.

6_while.md

@@ -0,0 +1,45 @@
+# Costrutto while e do-while
+
+TODO: link esercizio "ciao mondo"
+
+##  Le istruzioni iterative
+Le istruzioni iterative, anche chiamate di iterazione o cicliche, sono l'ultimo costrutto (di controllo) fondamentale della programmazione strutturata; permettono di ripetere una data istruzione (semplice o composta) fintantoché una condizione risulta vera. Per il teorema di Jacopini-Bohm posso implementare qualsiasi algoritmo usanto struttre di controllo iterative, condizionali e istruzioni composte.
+
+Il linguaggio C++ fornisce tre differenti tipi di istruzioni iterative, per aumentare l'espressività del linguaggio:
+- while
+- do ... while
+- for
+
+## Sintassi while
+<istruzione-while> ::= while(<condizione>) <istruzione>
+
+Il corpo del ciclo viene ripetuto finché la condizione è vera; appena risulta falsa si esce dal ciclo. L'istruzione deve modificare la condizione per evitare un ciclo infinito.
+
+### Parantesi su invocazione comandi bash
+All'interno di un programma C/C++ possono essere invocati comandi bash, attraverso la funzione _system_: `system("<comando>");`. L'esecuzione del programma non esce dalla funzione system finchè il comando lanciato non termina. Necessario importare `stdlib.h`.
+
+TODO: link esercitazioni fino a stampa secondi
+
+### time
+Libreria `<ctime.h>`
+
+L'istruzione `time(0)` ritorna il numero di secondi trascorsi a partire dall'epoch (1 gennaio 1970).
+
+### Segnali di interruzione
+Premento Ctrl+C mentre un processo in esecuzione, viene mandato il segnale SIGINTR (interruzione) a quest'ultimo. Se questo non dovesse bastare è necessario recuperare il suo _pid_ attraverso `ps x` o `ps ax`, quindi inviare un segnale di interruzione SIGKILL con `kill -9 <pid>`.
+
+### Modificatori stdout
+Il carattere speciale "\r" inviato sullo stdout riporta il cursore all'inizio della riga
+
+Il manipolatore `flush` equivale a fare `fflush(stdout)`, quindi forza il buffer di output ad essere stampato.
+
+## Struttura dati
+=> insieme di oggetti (variabili o costanti) con nome. Le strutture dati vengono utilizzate per rappresentare dati del problema reale.
+
+## do ... while
+
+### Sintassi
+<istruzione-do-while> :: = do <istuzione> while(<condizione>);
+
+### Semantica
+=> il costrutto `do ... while` è equivalente al `while`, escluso l'ordine in cui viene eseguito il corpo del ciclo e la condizione. In questo modo il corpo del ciclo viene sempre eseguito almeno una volta (torna utile, per esempio, nel controllo di valori di input).

esercitazioni/ciao_mondo_n_volte.cpp

@@ -0,0 +1,18 @@
+#include <iostream>
+
+using namespace std;
+
+int main() {
+	int n;
+
+	cout << "Numero N: ";
+	cin >> n;
+
+	int i = 0;
+	while (i<n) {
+		cout << "Ciao mondo" << endl;
+		i++;
+	}
+
+	return 0;
+}

esercitazioni/fattoriale.cpp

@@ -0,0 +1,28 @@
+#include <iostream>
+#include <limits.h>
+
+using namespace std;
+
+inline const int int_prod_overflow(const int a, const int b) {
+	return	(( ((a>0 && b>0) || (a<0 && b<0)) && b!=0 && abs(a)>abs(INT_MAX/b) )
+			||
+			( ((a<0 && b>0) || (a>0 && b<0)) && b!=0 && abs(a)>abs(INT_MIN/b) ));
+}
+
+int main() {
+	int n, fat = 1;
+	do {
+		cout << "Numero n diverso da 0: ";
+		cin >> n;
+	} while (n==0);
+	// for (int i=1; i<=n; fat*=i, i++) ;
+	bool overflow = false;
+	for (int i=1; i<=n; i++) {
+		overflow = overflow || int_prod_overflow(fat, i);
+		fat *= i;
+	}
+	cout << "Risultato: " << fat << endl;
+	if (overflow)
+		cout << "Risultato inattendibile causa overflow" << endl;
+	return 0;
+}

esercitazioni/ls_from_cpp.cpp

@@ -0,0 +1,11 @@
+#include <iostream>
+#include <stdlib.h>
+
+using namespace std;
+
+int main() {
+	int status;
+	status = system("ls");
+	cout << "ho finito" << endl;
+	return status;
+}

esercitazioni/overflow_checker_prod.cpp

@@ -1 +1,27 @@
-// TODO: verifica overflow in prodotto
+#include <iostream>
+#include <limits.h>
+
+using namespace std;
+
+int main() {
+	int	a,		// fattore 1
+		b,		// fattore 2
+		res;	// prodotto
+
+	cout << "Immettere i due fattori: ";
+	cin >> a >> b;
+
+	bool overflow = false;
+	res = a*b;
+	if (((a>0 && b>0) || (a<0 && b<0)) && b!=0 && abs(a)>abs(INT_MAX/b))
+		overflow = true;
+	else if (((a>0 && b<0) || (a<0 && b>0)) && b!=0 && abs(a)>abs(INT_MIN/b))
+		overflow = true;
+
+	cout << a << " * " << b << " = " << res << endl;
+	if (overflow) {
+		cout << "Attenzione: operazione soggetta a overflow" << endl;
+		return 1;
+	}
+	return 0;
+}

esercitazioni/overflow_checker_sum.cpp

@@ -0,0 +1,26 @@
+#include <iostream>
+#include <limits.h>
+
+using namespace std;
+
+int main() {
+	int a, b, res;
+
+	cout << "Inserisci i due numeri da sommare: ";
+	cin >> a >> b;
+
+	res = a+b;
+	bool overflow = false;
+	if (a>0 && b>0 && INT_MAX-b<a)
+		overflow = true;
+	else if (a<0 && b<0 && INT_MIN-b>a)
+		overflow = true;
+
+	cout << a << " + " << b << " = " << res << endl;
+
+	if (overflow) {
+		cout << "Attenzione: il risultato non è attendibile causa overflow" << endl;
+		return 1;
+	}
+	return 0;
+}

esercitazioni/quadrato_pieno.cpp

@@ -0,0 +1,20 @@
+#include <iostream>
+
+using namespace std;
+
+int main() {
+	const int MAX = 10;
+	int l;
+	do {
+		cout << "Lato: ";
+		cin >> l;
+	} while (!(l>0 && l<=MAX));
+
+	for (int i=0; i<l; i++) {
+		for (int j=0; j<l; j++) {
+			cout << "# ";
+		}
+		cout << endl;
+	}
+	return 0;
+}

esercitazioni/quadrato_pieno_non_nidificato.cpp

@@ -0,0 +1,19 @@
+#include <iostream>
+
+using namespace std;
+
+int main() {
+	const int MAX = 10;
+	int l;
+	do {
+		cout << "Lato: ";
+		cin >> l;
+	} while (!(l>0 && l<=MAX));
+
+	for (int i=1; i<=l*l; i++) {
+		cout << "# ";
+		if (i%l==0)
+			cout << endl;
+	}
+	return 0;
+}

esercitazioni/quadrato_vuoto.cpp

@@ -0,0 +1,22 @@
+#include <iostream>
+
+using namespace std;
+
+int main() {
+	const int MAX = 10;
+	int l;
+	do {
+		cout << "Lato: ";
+		cin >> l;
+	} while (!(l>0 && l<=MAX));
+
+	for (int i=1; i<=l*l; i++) {
+		if (i%l == 0 || i%l == 1 || i<=l || i>=l*l-l)
+			cout << "# ";
+		else
+			cout << "  ";
+		if (i%l==0)
+			cout << endl;
+	}
+	return 0;
+}

esercitazioni/somma_e_max_1.cpp

@@ -0,0 +1,42 @@
+#include <iostream>
+#include <limits.h>
+
+using namespace std;
+
+inline const bool int_sum_overflow(const int a, const int b)  {
+	return ((a>0 && b>0 && a>INT_MAX-b) || (a<0 && b<0 && a<INT_MIN-b));
+}
+
+int main() {
+	const int MAX = 10;
+
+	// Immissione n e sanificazione range input
+	int n;
+	do {
+		cout << "Numeri da sommare: ";
+		cin >> n;
+		if (!(0<=n && n<=MAX))
+			cout << "Valore non consentito" << endl;
+	} while (!(0<=n && n<=MAX));
+
+	// Calcolo iterativo somma e ricerca minimo
+	int num_max = 0, s = 0;
+	bool overflow = false;
+	for (int i=0, num; i<n; i++) {
+		cout << "Prossimo numero: ";
+		cin >> num;
+		if (int_sum_overflow(num, s))
+			overflow = true;
+		s += num;
+		if (num > num_max)
+			num_max = num;
+	}
+
+	cout 
+		<< "Massimo numero inserito: " << num_max << endl
+		<< "Somma: " << s << endl;
+	if (overflow)
+		cout << "Somma inattendibile a causa di overflow" << endl;
+
+	return 0;	
+}

esercitazioni/somma_primi_n_numeri.cpp

@@ -0,0 +1,16 @@
+#include <iostream>
+
+using namespace std;
+
+int main() {
+	int s, i, n;
+	cout << "Numero N: ";
+	cin >> n;
+	s = i = 0;
+	while (i<n) {
+		i++;
+		s+=i;
+	}
+	cout << s << endl;
+	return 0;
+}

esercitazioni/somma_primi_n_numeri_for.cpp

@@ -0,0 +1,12 @@
+#include <iostream>
+
+using namespace std;
+
+int main() {
+	int n, s = 0;
+	cout << "Numero N: ";
+	cin >> n;
+	for (int i=1; i<=n; s+=i, i++) ;
+	cout << s << endl;
+	return 0;
+}