From 91751aee68ab1876cec8861e1c00d4c49a15c7de Mon Sep 17 00:00:00 2001 From: mc-cat-tty <44820563+mc-cat-tty@users.noreply.github.com> Date: Tue, 19 Oct 2021 07:38:06 +0200 Subject: [PATCH] recupero lezione 6 --- 5_dimensioni_dato.md | 22 +++++++-- 5_fasi_sviluppo.md | 10 +++- 6_for.md | 32 +++++++++++++ 6_istruzione_vuota.md | 2 + 6_while.md | 45 ++++++++++++++++++ esercitazioni/a.out | Bin 16904 -> 16840 bytes esercitazioni/ciao_mondo_n_volte.cpp | 18 +++++++ esercitazioni/fattoriale.cpp | 28 +++++++++++ esercitazioni/ls_from_cpp.cpp | 11 +++++ esercitazioni/overflow_checker.cpp | 9 ---- esercitazioni/overflow_checker_prod.cpp | 28 ++++++++++- esercitazioni/overflow_checker_sum.cpp | 26 ++++++++++ esercitazioni/quadrato_pieno.cpp | 20 ++++++++ .../quadrato_pieno_non_nidificato.cpp | 19 ++++++++ esercitazioni/quadrato_vuoto.cpp | 22 +++++++++ esercitazioni/somma_e_max_1.cpp | 42 ++++++++++++++++ esercitazioni/somma_primi_n_numeri.cpp | 16 +++++++ esercitazioni/somma_primi_n_numeri_for.cpp | 12 +++++ esercitazioni/stampa_secondi.cpp | 13 +++++ esercitazioni/stampa_secondi_trascorsi.cpp | 19 ++++++++ 20 files changed, 377 insertions(+), 17 deletions(-) create mode 100644 6_for.md create mode 100644 6_istruzione_vuota.md create mode 100644 6_while.md create mode 100644 esercitazioni/ciao_mondo_n_volte.cpp create mode 100644 esercitazioni/fattoriale.cpp create mode 100644 esercitazioni/ls_from_cpp.cpp delete mode 100644 esercitazioni/overflow_checker.cpp create mode 100644 esercitazioni/overflow_checker_sum.cpp create mode 100644 esercitazioni/quadrato_pieno.cpp create mode 100644 esercitazioni/quadrato_pieno_non_nidificato.cpp create mode 100644 esercitazioni/quadrato_vuoto.cpp create mode 100644 esercitazioni/somma_e_max_1.cpp create mode 100644 esercitazioni/somma_primi_n_numeri.cpp create mode 100644 esercitazioni/somma_primi_n_numeri_for.cpp create mode 100644 esercitazioni/stampa_secondi.cpp create mode 100644 esercitazioni/stampa_secondi_trascorsi.cpp diff --git a/5_dimensioni_dato.md b/5_dimensioni_dato.md index 8fb8813..36dad32 100644 --- a/5_dimensioni_dato.md +++ b/5_dimensioni_dato.md @@ -1,12 +1,24 @@ # Tipi di dato -## sizeof() -Ritorna la dimensione di un tipo di dato oppure di un espressione (variabile, espressione numerica, confronto) -TODO: vedi esercizio +## Operatore sizeof() +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-ba_ +TODO: link esercizio check overflow di somma e moltiplicazione diff --git a/5_fasi_sviluppo.md b/5_fasi_sviluppo.md index 93c52fa..48eea22 100644 --- a/5_fasi_sviluppo.md +++ b/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 diff --git a/6_for.md b/6_for.md new file mode 100644 index 0000000..36b72e8 --- /dev/null +++ b/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 + ::= + for(; ; ) // Intestazione del ciclo for + + +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 , , ..., si può ottenere una _espressione composta_ concatenandole con l'operatore virgola: `, , ..., `. 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. + diff --git a/6_istruzione_vuota.md b/6_istruzione_vuota.md new file mode 100644 index 0000000..e65bc57 --- /dev/null +++ b/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. diff --git a/6_while.md b/6_while.md new file mode 100644 index 0000000..981e58f --- /dev/null +++ b/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 + ::= while() + +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("");`. 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 `` + +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 `. + +### 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 + :: = do while(); + +### 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). diff --git a/esercitazioni/a.out b/esercitazioni/a.out index a1653d38781062ba2ad50f5804e270e7e5861408..0ef699b66d81382c9e7f390a3b2a7320e19dd35c 100755 GIT binary patch delta 2271 zcmZWreQZ-z6u-A0TU)xWAFFR=NZ)`71-G^g*oJg%g}S#0IFZ3b5T{@$Az25Vi8{8) zgshgDmZJuhs6>cDFhClT#rRQ>u*E+NQ!!bDWHV7_T;k>s1_7SuzK?~>yS#he{hi@yJ@=EmbMaUgk(X4jOR0BgHc{JWCp#a<63!fTnlzuVT@6E8H0N2rM>Vf z6>UYlj7>>MXvCs{V^7UUcC`0h+xXjD=ea%eo?N^4TR5U!;Itr{dC8NktQtym!~%ob z`E(gj9S1pGG5B=F)B_nEN526-&R?(@e3g0dp3Y8h!g-ySMqpf5N8gq77I<3E(Ss1x z@62A)N9h(qG?IHQVSn}z`m7Wmr0(L%Ul_%OSx=uF-rYZ^YWKGgUJ7A~X;S|kw|K&I%N z<0a%qT1W*l_#&kAZ!u9b8Fvav{rw7j-=B*c#i2rX7xVv}B9Y%L@t1Cb8MayU3M{bA zUbxqfl(x!7p*ye-O^J~BJzgLr1I&-;jNv@;k|>Io^y?vJ^L6sugru%)fkcc<`g47e z8z#0$={H!I@g;ogMM@Mfaqs^Fm)_jGft^ zAK;W+Gn$Nyy?^U=;xbmT=z(STB#n2LpiNC=tizFPMBZrO=?nPcxr|VI35FiT6PClR zQj#!ZxW8PeIzOfID5~*$n8}0T+FZDS&y}k#sKOgWUN@$Qk;>$l7_RW`^|&p)m@yHO zjg#AiMMcuK#PuUz!d6FF`8B29BWR7`w@Yp>;M+w>aS21+epKF)ntO28G1HfxD4cyK zym56ZuxBA5;SKePU&4*`iGRcE!->0%LaKZh!q2Ss+!MM-4I`)TW<>`zL)v)e5U*Ri zx;fsmoF{X6!t*RCTB3a{gfbr=^Oz{cQMRMpjIwQ96px@h_Kzrjh4LoKt0>JAqIef& z`vmOfA9=VK>6j}atMaA3G7n#u;FJDa6k~9XpF3xOG1$?CE!G2?l?8d)h18sHAhQr^ z$7g69?(nmz9bBbuYJi&3I_k^5QR-${^M3WpnH)&Pp=n<`9nf0grY9j&5u|AtsBqhI%GG3bv(W?88>H0`_PQ~TX7BZ>%h~|X`absO zl$I&83BfJKo?szk({R=n814g)zm9f6t3OCD!dXA(`AO0A+GQW>WI?o;H?vU7bHaen zZR8N8#7=gBYw>)4nN*vNsJ&J(B~EN|8e*24n+l?=hStTLD=b+#$Qh+qsf2ZKbTL=I zU5daF5>jzlzK*z+6qBZD_+@M@JmSJMd>_zCj%HXBciGX_jUD5}K6d%*lxHMul74Z7D}LLo3d&F(yq&^QVaPTUy(ix9!H;yY-c}mUv5c z&9W^T$mnNfuU3!HZ2$5XD1L386<*s8#hofoLKIQE@}aAehZ8Hj#%cwvhT#=e#vWzW z1EqngsT-o+lr%&Goraj4DuGOZgZx_C)c+Fd!RWzL>ouu|i1+Ws+9#+DPSkph>epKY z!?jh$CSG>clr0U`Q7S+*QhC`2C&E?K J3&Y|0{{gDj{@nlo delta 2537 zcmZuzZ){Ul6u-A?w-(m5-MVyDp>I<%3bL+jFu`?eVb8rKsEj!+$Yf)iv9do3Ly@Q( zBBn33rtC!2hzcLjeKSx5Oo*(2TU8Q=F(||jEMhD=b?7vp!{@p8y|s0tF@>wV7>wWwNj??vC7W}~V!8zG;TSrSxL6VO0?bQqqY zilb6cu^9=nL2*8Q>f}WH^9twU2U}ig+`MxA^0CkFfc;qu3vI||QL?$0-9U+v*x+JT zDGdTOy6D5;H@cwQSVSveFY0Ng)8o7^;Rsp6efI{3?e8~qrH9P<}-`;oG}qFLG<*ov-1lE3S-O0mEn zs3?W4*k{@mMHw;GL93&@KiDC~j0+ZWqIlguJSvW*Q5hA#T*}4Q9b9~4&tu@_YDSEk z7NI7|Blxu+14{B}rsHo#k>cW66@8cGg=iU~F$CMkq{tVZJwG-|sUL*YpV_JF9yukC zdDH!}cxBgfS6K9Z+o+gk+aM-hk;QXAK0hjE2BznrdUmmxk;RFaI59hraVC%~PX5n8 zrhnO|V&bI9h6Ak-r=E9eWA!tTjm}22B52?VOreU!ZN$B&7Ib`xT2TK@EK@!m6Vq6| z{8i?CRY&e!8W+J0I_aF$o|Yn?$kAw2N?jFbDs_WrG$N0EU*jNoQq ztZ?v7hFoAX=|bcL=0>Dg^YspCv6HV^pDB|E$@~TVer>`hr`a-?Qrz)0eid=U2yUc% zIX0S!BPH?4nP%J=A1MkUr`Vil-o!o8f;+2@kl$?c{|r5}CLTEBB_#A+#vrR zdLSfEH%sv)ClPL1(a+(E(EUl-}_?AaFS?dcRAjdXPj4{zDr zvQi*Tom-#k+$sCVo+rK9pUPin0-9=QTyykFxwX zMLCJ`1(e^Q+>de^W$u)s)M4^Y{AP{rTnFt!;XE_?W7UMzAiQ&V*`3fGo+43ZP_%O0Tv@MM{X9)-PSwR8y1mw6nQwVR1e z0&7D+eYG?UA)kj7+QrwNGo zYgc@V7{yEa!&NFvPwb+`?a<0ur<#cc2`t7j826W2=AlMOK6x1&OH190xwC`l?~mp} zZiU9BE_V&*7LpU%m8@IqVHaA%+_!)nm}T7phnKnVLLL{NF!+euzy4;v(m*#&vz4Q+P#awF{sd%oN^n5UtL=ud;{kB=lgS>bZG;N6^W zun|e$S(-h-$l`i*}Xl2#TuBr*z z&^peo?*I7y#3MUchM2>cwr-tThQ-jh%tfmpg%O%GPEf0YJy@)@!?j8m-NBjr7?U32 z{V7D!&W_%vd%AktIyODJwYPiIHhylCrOR6k&JF5Y9tqa3X;`&79Ntt>RtZm=<|hx_ zm7y?fFealbTPYrwt9Sbx1KMc1JPO`wpQBRS;kqn=NVU%r*3d8M30d-k{H-FUMMF3)a$BILQ0)VC|e8X_mgq87{T3pjD!K&@ HhD!ed^;v^K diff --git a/esercitazioni/ciao_mondo_n_volte.cpp b/esercitazioni/ciao_mondo_n_volte.cpp new file mode 100644 index 0000000..b8f330c --- /dev/null +++ b/esercitazioni/ciao_mondo_n_volte.cpp @@ -0,0 +1,18 @@ +#include + +using namespace std; + +int main() { + int n; + + cout << "Numero N: "; + cin >> n; + + int i = 0; + while (i +#include + +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; +} diff --git a/esercitazioni/ls_from_cpp.cpp b/esercitazioni/ls_from_cpp.cpp new file mode 100644 index 0000000..d7c947d --- /dev/null +++ b/esercitazioni/ls_from_cpp.cpp @@ -0,0 +1,11 @@ +#include +#include + +using namespace std; + +int main() { + int status; + status = system("ls"); + cout << "ho finito" << endl; + return status; +} diff --git a/esercitazioni/overflow_checker.cpp b/esercitazioni/overflow_checker.cpp deleted file mode 100644 index c16bc20..0000000 --- a/esercitazioni/overflow_checker.cpp +++ /dev/null @@ -1,9 +0,0 @@ -#include - -using namespace std; - -int main() { - int ; - // TODO: verifica overflow somma e sottrazione - return 0; -} diff --git a/esercitazioni/overflow_checker_prod.cpp b/esercitazioni/overflow_checker_prod.cpp index 2af4c5d..076b867 100644 --- a/esercitazioni/overflow_checker_prod.cpp +++ b/esercitazioni/overflow_checker_prod.cpp @@ -1 +1,27 @@ -// TODO: verifica overflow in prodotto +#include +#include + +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; +} diff --git a/esercitazioni/overflow_checker_sum.cpp b/esercitazioni/overflow_checker_sum.cpp new file mode 100644 index 0000000..69c0bb8 --- /dev/null +++ b/esercitazioni/overflow_checker_sum.cpp @@ -0,0 +1,26 @@ +#include +#include + +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-ba) + overflow = true; + + cout << a << " + " << b << " = " << res << endl; + + if (overflow) { + cout << "Attenzione: il risultato non è attendibile causa overflow" << endl; + return 1; + } + return 0; +} diff --git a/esercitazioni/quadrato_pieno.cpp b/esercitazioni/quadrato_pieno.cpp new file mode 100644 index 0000000..32a681c --- /dev/null +++ b/esercitazioni/quadrato_pieno.cpp @@ -0,0 +1,20 @@ +#include + +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 + +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; +} diff --git a/esercitazioni/quadrato_vuoto.cpp b/esercitazioni/quadrato_vuoto.cpp new file mode 100644 index 0000000..7f26d8e --- /dev/null +++ b/esercitazioni/quadrato_vuoto.cpp @@ -0,0 +1,22 @@ +#include + +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; +} diff --git a/esercitazioni/somma_e_max_1.cpp b/esercitazioni/somma_e_max_1.cpp new file mode 100644 index 0000000..2d93e79 --- /dev/null +++ b/esercitazioni/somma_e_max_1.cpp @@ -0,0 +1,42 @@ +#include +#include + +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> 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> 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; +} diff --git a/esercitazioni/somma_primi_n_numeri.cpp b/esercitazioni/somma_primi_n_numeri.cpp new file mode 100644 index 0000000..4f07399 --- /dev/null +++ b/esercitazioni/somma_primi_n_numeri.cpp @@ -0,0 +1,16 @@ +#include + +using namespace std; + +int main() { + int s, i, n; + cout << "Numero N: "; + cin >> n; + s = i = 0; + while (i + +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; +} diff --git a/esercitazioni/stampa_secondi.cpp b/esercitazioni/stampa_secondi.cpp new file mode 100644 index 0000000..72cf2fa --- /dev/null +++ b/esercitazioni/stampa_secondi.cpp @@ -0,0 +1,13 @@ +#include +#include +#include + +using namespace std; + +int main() { + while (true) { + cout << time(0) << endl; + system("sleep 1"); + } + return 0; +} diff --git a/esercitazioni/stampa_secondi_trascorsi.cpp b/esercitazioni/stampa_secondi_trascorsi.cpp new file mode 100644 index 0000000..05a56f7 --- /dev/null +++ b/esercitazioni/stampa_secondi_trascorsi.cpp @@ -0,0 +1,19 @@ +#include +#include +#include + +using namespace std; + +int main() { + int start_time, sec = 0, sec_max = 10; + // cout << "Numero massimo di secondi da attendere: "; + // cin >> sec_max; + start_time = time(0); + while (sec