From 4a6caa14a22a74ec4fe37a9b11b32732e41a2f9e Mon Sep 17 00:00:00 2001 From: mc-cat-tty <44820563+mc-cat-tty@users.noreply.github.com> Date: Thu, 28 Oct 2021 10:16:05 +0200 Subject: [PATCH] lezione 10 --- 10_char.md | 25 +++++++++ 10_compendio_bool.md | 8 +++ 10_operatore_ternario.md | 6 +++ "10_visibilit\303\240_e_tempo_di_vita.md" | 55 +++++++++++++++++++ esercitazioni/congettura_goldbach.cpp | 66 +++++++++++++++++++++++ esercitazioni/gen_primi_gemelli.cpp | 43 +++++++++++++++ esercitazioni/oper_cond.cpp | 10 ++++ esercitazioni/oper_cond2.cpp | 11 ++++ esercitazioni/prova_teorica_1.cpp | 16 ++++++ esercitazioni/scope_var.cpp | 31 +++++++++++ 10 files changed, 271 insertions(+) create mode 100644 10_char.md create mode 100644 10_compendio_bool.md create mode 100644 10_operatore_ternario.md create mode 100644 "10_visibilit\303\240_e_tempo_di_vita.md" create mode 100644 esercitazioni/congettura_goldbach.cpp create mode 100644 esercitazioni/gen_primi_gemelli.cpp create mode 100644 esercitazioni/oper_cond.cpp create mode 100644 esercitazioni/oper_cond2.cpp create mode 100644 esercitazioni/prova_teorica_1.cpp create mode 100644 esercitazioni/scope_var.cpp diff --git a/10_char.md b/10_char.md new file mode 100644 index 0000000..fb01cb2 --- /dev/null +++ b/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. diff --git a/10_compendio_bool.md b/10_compendio_bool.md new file mode 100644 index 0000000..33ed322 --- /dev/null +++ b/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 && || ... || +true || || ... || + +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 diff --git a/10_operatore_ternario.md b/10_operatore_ternario.md new file mode 100644 index 0000000..4b9e5ff --- /dev/null +++ b/10_operatore_ternario.md @@ -0,0 +1,6 @@ +# Operatore ternario + ? : + +Il valore risultante dell'intera espressione è se è vera, altrimenti. + +TODO: link esercizio oper_cond.cpp diff --git "a/10_visibilit\303\240_e_tempo_di_vita.md" "b/10_visibilit\303\240_e_tempo_di_vita.md" new file mode 100644 index 0000000..f90ab8a --- /dev/null +++ "b/10_visibilit\303\240_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 diff --git a/esercitazioni/congettura_goldbach.cpp b/esercitazioni/congettura_goldbach.cpp new file mode 100644 index 0000000..b27f9fc --- /dev/null +++ b/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 + +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 +#include + +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 + +using namespace std; + +int main() { + int n; + cin >> n; + n<0 ? n=0 : 0; // 0 corrisponde ad una nop + cout << n << endl; +} diff --git a/esercitazioni/oper_cond2.cpp b/esercitazioni/oper_cond2.cpp new file mode 100644 index 0000000..4d1f222 --- /dev/null +++ b/esercitazioni/oper_cond2.cpp @@ -0,0 +1,11 @@ +#include + +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; +} diff --git a/esercitazioni/prova_teorica_1.cpp b/esercitazioni/prova_teorica_1.cpp new file mode 100644 index 0000000..957db89 --- /dev/null +++ b/esercitazioni/prova_teorica_1.cpp @@ -0,0 +1,16 @@ +#include + +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; +} diff --git a/esercitazioni/scope_var.cpp b/esercitazioni/scope_var.cpp new file mode 100644 index 0000000..71908e8 --- /dev/null +++ b/esercitazioni/scope_var.cpp @@ -0,0 +1,31 @@ +#include + +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); +}