lezione 10

10_char.md

@@ -0,0 +1,25 @@
+# Tipo primitivo char
+Tipo primitivo del C/C++. Occupa 1 byte (unità minima di memorizzazione quando differente)
+
+## Caratteri speciali
+Necessario l'escaping dei caratteri
+
+'\n'	A capo
+'\t'	Tab
+'\''	Apice singolo
+'\\'	Backslash
+'\"'	Doppio apice
+
+## Rappresentazione dei caratteri
+=> associare per convenzione un numero interno (codice) ad ogni carattere
+Per una corretta interpretazione dei caratteri è necessario indicare al calcolatore che una data locazione di memoria contiene un carattere -> tipo _char_
+
+## Codice ASCII
+=> codifica che, nella forma estesa, associa a 256 caratteri (occupa 1 byte) un codice. Nella forma ristretta vengono utilizzati solamente 7 bit.
+
+## Tipo char
+Sottoinsieme degli int rappresentabili con un solo byte.
+`char` tradizionale - 1 byte - da -128 a 127
+`unsigned char` - 1 byte - da 0 a 255
+
+Per definizione l'unsigned char è sempre senza segno, mentre per il char non è definito dallo standard se debba avere segno o no.

10_compendio_bool.md

@@ -0,0 +1,8 @@
+# Compendio bool
+## Corto circuito logico
+Un operatore logico binario è valutato in *corto circuito logico* se il secondo operando non è valutato se il risultato del primo è sufficiente a stabilire il risultato dell'operazione.
+### Esempi
+false && <espressione> || ... || <espressione>
+true || <espressione> || ... || <espressione>
+
+In entrambi i casi l'espressione non viene valutata (ricorda che entrambi gli operatori sono associativi a sinistra). In caso di una serie di n espressioni ci si ferma appena il risultato è sufficiente a determinare il risultato della catena di operazioni

10_operatore_ternario.md

@@ -0,0 +1,6 @@
+# Operatore ternario
+<condizion> ? <espressione1> : <espressione2>
+
+Il valore risultante dell'intera espressione è <espressione1> se <condizione> è vera, <espressione2> altrimenti.
+
+TODO: link esercizio oper_cond.cpp

10_visibilità_e_tempo_di_vita.md

@@ -0,0 +1,55 @@
+# Visibilità e tempo di vita degli oggetti
+
+## Dichiarazioni globali
+=> dichiarazione variabili e costanti fuori dal corpo di una funzione.
+
+Possono essere inserite 
+
+## Variabile locale
+= contrario di _Globale_. In questo caso la variabile è locale ad un blocco.
+
+## Caratteristiche statiche e dinamiche
+Caratteristica statica: non cambia durante l'esecuzione del programma
+Caratteristica dinamico: cambia durante esecuzione programma
+
+### Esempio
+Una variabile ha:
+	- nome statico
+	- indirizzo statico
+	- valore dinamico
+	- tipo statico
+
+Il C/C++ è un linguaggio con tipizzazione STATICA e FORTE (il tipo viene controllato dal compilatore)
+
+## Visibilità e tempo di vita
+Visibilità = arte del testo del programma in cui si può utilizzare un certo itentificatore. Regole di visibilità statiche.
+Tempo di vita = in quali momenti della vita del programma. Il tempo di vita degli identificatori è DINAMICO in C/C++.
+
+### Blocco
+Il campo di visibilità di un identificatore dichiarato all'interno di un blocco di codice è il blocco stesso (dal punto della dichiarazione alla fine del blocco).
+L'unica eccezione viene rappresentata dai blocchi innestati: _shadowing_. In questo caso l'identificatore del blocco esterno rimane in vita, ma viene "nascosto" ad esso (non visibile nel blocco innestato). ATTENZIONE: lo shadowing avviene solamente se nel blocco interno ridefinisco l'identificatore, se lo utilizzo solamente viene modificato il valore di quello esterno.
+
+Il tempo di vita va dal momento della definizione alla fine del blocco stesso.
+
+### Corpo del main
+Tempo di vita pari alla durata dell'intero programma (coincide con il tempo di vita del main).
+
+Campo di visibilità limitato al corpo del main.
+
+### Identificatori globali
+Tempo di vista pari alla durata dell'intero programma.
+
+Visibili dal punto della dichiarazione fino alla fine del file. Se in presenza di blocchi innestati -> shadowing.
+
+## Unicità identificatori
+L'associazione di un identificatore ad un oggetto è UNICO per tutto il suo campo di visibilità.
+
+## Valori iniziali
+Il valore iniziale di una variabile GLOBALE è ZERO; in tutti gli altri casi è casuale (garbage).
+
+TODO: add esercizio scope
+
+## Dipendenze
+Tra tue parti di un programma si dice che c'è dipendenza se una delle due parti funziona correttamente solo se anche l'altra funziona correttamente.
+
+Questo va in contrasto con l'utilizzo delle variabili globali, perchè generano dipendenza con tutti i punti del programma in cui vengono utilizzate. -> aumentano complessità programma

esercitazioni/congettura_goldbach.cpp

@@ -0,0 +1,66 @@
+/*
+ Secondo la congettura di Goldbach ogni numero primo maggiore di 2 può essere scritto come sommma di due numeri primi
+*/
+
+#include <iostream>
+
+using namespace std;
+
+const int fine_intervallo_goldbach(const int a, const int b);  // ritorna il primo numero (dell'intervallo), se esiste, che non rispetta la congettura
+const bool is_goldbach(const int n);
+const bool is_primo(const int n);
+// const int prossimo_primo(const int n);  // primo numero primo successivo ad a
+
+int main() {
+	int a, b;
+	do {
+		cout << "Estremi: "; cin >> a >> b;
+	} while (!(a>2 && b>2));
+	cout << fine_intervallo_goldbach(a, b) << endl;
+	return 0;
+}
+
+const bool is_primo(const int n) {
+	for (int i=2; i<n; i++)
+		if (n%i == 0)
+			return false;
+	return true;
+}
+
+/*
+const int prossimo_primo(const int n) {
+	for (int i=n; ; i++)
+		if (is_primo(i))
+			return i;
+}*/
+
+/*const bool is_goldbach(const int n) {
+		for (int i=1; i<=n/2; i++) {
+			for (int j=1; j<=n/2; j++) {
+				if (prossimo_primo(j) + prossimo_primo(i) == n)
+					return true;
+			}
+		}
+		return false;
+}*/
+
+const bool is_goldbach(const int n) {  // Versione ottimizzata
+		for (int p1=2; p1<=n/2; p1++) {
+			if (is_primo(p1) && is_primo(n-p1)) {
+				cout << "[DEBUG]" << n << "=" << p1 << "+" << n-p1 << endl;  // Add tracing
+				return true;
+			}
+		}
+		return false;
+}
+
+const int fine_intervallo_goldbach(const int a, const int b) {
+	int start = a, end = b;
+	if (start%2 != 0)  // se numero dispari
+		start++;  // diventa pari
+	for (int i=start; i<=end; i+=2) {
+		if (!is_goldbach(i))
+			return i;
+	}
+	return 0;  // se tutti i numeri rispettano la congettura ritorno un valore fuori dal range
+}

esercitazioni/gen_primi_gemelli.cpp

@@ -0,0 +1,43 @@
+#include <iostream>
+#include <cmath>
+
+using namespace std;
+
+bool is_primo(const int n);
+bool is_primi_gemelli(const int a, const int b);
+int primo_dispari_dopo(const int n);
+
+// misura tempo di esecuzione con "time" (comando bash)
+int main() {
+	int a, b;
+	do {
+		cout << "Estremi a e b non negativi: "; cin >> a >> b;
+	} while (!(a>0 && b>0));
+
+	// parto dal primo dispari disponibile e scorro solamente i numeri dispari
+	for (int i=primo_dispari_dopo(a); i<b-1; i+=2) {  // Arrivo fino a b-1 perchè nel corpo del ciclo faccio i+2 (arriva esattamente a b) 
+		if (is_primi_gemelli(i, i+2))
+			cout << "Primi gemelli: " << i << " " << i+2 << endl;
+	}
+	return 0;
+}
+
+int primo_dispari_dopo(const int n) {
+	if (n%2 == 0)
+		return n+1;
+	return n;
+}
+
+bool is_prime(const int n) {  // Può essere ottimizzata
+	for (int i=2; i<n; i++) {
+		if (n%i == 0)
+			return false;
+	}
+	return true;
+}
+
+bool is_primi_gemelli(const int a, const int b) {
+	if (abs(a-b) == 2 && is_prime(a) && is_prime(b))
+		return true;
+	return false;
+}

esercitazioni/oper_cond.cpp

@@ -0,0 +1,10 @@
+#include <iostream>
+
+using namespace std;
+
+int main() {
+	int n;
+	cin >> n;
+	n<0 ? n=0 : 0;  // 0 corrisponde ad una nop
+	cout << n << endl;
+}

esercitazioni/oper_cond2.cpp

@@ -0,0 +1,11 @@
+#include <iostream>
+
+using namespace std;
+
+int main() {
+	int n;
+	cin >> n;
+	n<0 ? n=0 : 0;  // 0 corrisponde ad una nop
+	n>10 ? n=10 : 0;
+	cout << n << endl;
+}

esercitazioni/prova_teorica_1.cpp

@@ -0,0 +1,16 @@
+#include <iostream>
+
+using namespace std;
+
+int main(void) {
+	// definizione della "struttura dati" per la risoluzione del problema
+	int a, b;
+	int res = 1;  // se b<=0 non entro nel ciclo, il risultato è già calcolato
+	cout << "Valori: ";
+	cin >> a >> b;
+	for(int i=1; i<=b; i++) {
+		res *= a;
+}
+	cout << res << endl;
+	return 0;
+}

esercitazioni/scope_var.cpp

@@ -0,0 +1,31 @@
+#include <iostream>
+
+using namespace std;
+
+int x = 100;
+
+void fun(int n) {
+	cout << "	[fun] x chiamante: " << n << " e x globale: " << x << endl;
+	x++; cout << "	[fun] incremento" << endl;
+	cout << "	[fun] x chiamante: " << n << " e x globale: " << x << endl;
+	{
+		int x = 1;
+		cout << "	[fun] [blocco interno] x chiamante: " << n << " x blocco fun: " << x << endl;
+		x++; cout << "	[fun] incremento" << endl; 
+		cout << "	[fun] [blocco interno] x chiamante: " << n << " x blocco fun: " << x << endl;
+	}
+}
+
+int main() {
+	cout << "[main] x globale: " << x << endl;
+	x++; cout << "[main] incremento" << endl;
+	cout << "[main] x globale: " << x << endl;
+	{
+		int x = 5;
+		cout << "[main] [blocco interno] x blocco main: " << x << endl;
+		x++; cout << "[main] [blocco interno] incremento" << endl;
+		cout << "[main] [blocco interno] x blocco main: " << x << endl;
+		fun(x);
+	}
+	fun(x);
+}