Scarica Programmazione informatica e più Appunti in PDF di Programmazione C solo su Docsity!
PROGRAMMAZIONE
INTRODUZIONE
Orario : senza pausa. Mattina: 11:00 - 12: Pomeriggio: 13:00 – 14: Le due lezioni saltate si terranno a gennaio. Si studierà il linguaggio Go, molto popolare e recente. Esame :
- Prova individuale di programmazione
- Scritto di teoria o di lettura di programmi
- Prova di recupero (voto inferiore a 21), prova di eventuale miglioramento (voto tra 21 e 27) Salto di appello : chi risulta gravemente insufficiente negli appelli di gennaio o giugno non potrà sostenere gli appelli di febbraio e luglio, rispettivamente. Si ritiene che siano gravemente insufficienti (e quindi passibili di salto d'appello):
- Le persone iscritte all'appello che non si presentino alla prova di laboratorio; chi si fosse iscritto ma avesse deciso di non presentarsi può, per non incorrere nel salto d'appello, disiscriversi oppure (quando siano scaduti i termini per disiscriversi) mandare un’e-mail al docente del turno di laboratorio almeno il giorno prima della prova.
- Le persone che partecipano alla prova di laboratorio ma non superano l'esercizio filtro.
- Le persone che pur superando l'esercizio filtro consegnino nella prova di laboratorio esercizi contenenti errori che evidenzino gravi lacune.
- Non sono viceversa soggetti al salto d'appello gli studenti che, in qualunque momento della prova (di laboratorio o scritta), decidano di ritirarsi. Iscrizione agli appelli : gli studenti che vogliano sostenere l'esame a un dato appello devono iscriversi al SIFA (tramite il @SIFA online, o recandosi presso gli appositi chioschi). Questo vale per tutti gli appelli, compresi quelli di gennaio e febbraio.
Un computer è un device che permette di elaborare informazioni in maniera automatica. La memoria è basata su una serie di 0 e 1.
- Hardware : “ferramenta” in inglese. Si riferisce alla parte fisica e elettrica del computer. Si divide in: CPU: permette di manipolare i dati. Memoria: o RAM: posto principale in cui la CPU va a manipolare i dati. Ha bisogno di essere alimentata per mantenersi in vita. o Memoria di massa: es. nastri, dischi rigidi e SSD (chiavette USB). Non ha bisogno di alimentazione.
- Software : parte che pilota il computer. Turin : capì che si poteva costruire un computer che fosse in grado di fare ogni cosa, non come accadeva fino ad allora che per ogni cosa serviva un computer dedicato. Inventa la Macchina di Turin Universale. 1bit (unità di misura dell’informazione) -> 8bit = 1 byte (o octet) -> 01010101 unità di misura dell’informazione Come unità di misura un byte è un po’ più grosso in quanto si calcola in base 10 elevato per il numero di cifre: 932 = 10^3 Il bit invece è in base 2 elevato al numero delle cifre. 01010101 = 2^8 Prima si programmava in Assembly, poi abbiamo inventato linguaggi più semplici per noi, ma più difficili per la macchina, poi ancora facili sia per noi che per la macchina. Questi sono i Linguaggi ad Alto Livello e nascono negli anni 60/70. Si possono distinguere in:
- Interpretati : sono i più lenti. Nel momento in cui si scrive il programma, istantaneamente viene tradotto e si può usare.
- Compilati : si scrive il programma nel linguaggio che ci interessa che poi viene tradotto nel linguaggio della macchina e poi si può usare. Bisogna ricompilare il linguaggio per ogni macchina, in quanto ogni macchina funziona diversamente.
- Seminterpretati/Semicompilati : si ha una parte di interpretazione e una di compilazione. Trasforma il linguaggio umano in un linguaggio intermedio tra quello umano e quello della macchina. È più veloce del metodo compilato. Un esempio è JAVA. Il linguaggio creato è uguale per tutte le macchine, quando viene trasferito sulla macchina giusta viene adattato. Linguaggi :
- Imperativi : es. Go. Sono la maggioranza dei linguaggi usati oggi. Contengono istruzioni nell’ordine nel quale le cose devono essere eseguite. È il linguaggio che seguiremo in questo anno.
- Funzionali : molto usati anche questi, ma meno degli imperativi.
- Logici : l’unica cosa che si scrive sono degli assiomi (vincoli logici. Se questo e questo sono veri allora questo è vero).
- Oggetti : es. JAVA e C++. Simili agli imperativi, ma l’unità di aggregazione della funzione è l’aggregazione.
UNITÀ DI CALCOLO, IL MODELLO DI VON NEUMANN E IL LINGUAGGIO MACCHINA
Bit = unità fondamentale dell’informazione. Può assumere i valori 0 o 1. Byte = ottetto = ocbet = 8 bit = 2^8 bit I moltiplicatori delle unità base (byte) esistono nel S.I. e come notazione storica. Moltiplicatori nel S.I. : lavorano per multipli di 10 e sono dette misure del venditore di hard disk.
- Kilo: 10^3
- Mega: 10^6
- Giga: 10^9
- Tera: 10^12 Moltiplicatori “informatici” : vengono usate le potenze del 2 poiché sono quelle usate storicamente in informatica. Sono stati introdotti perché il solo segno “K”, “M”, “G”, “T” creava confusione coi moltiplicatori del S.I.
- KiB: 2^10
- MiB: 2^20
- GiB: 2^30
- TiB: 2^40 Il modello di Von Neumann è un modello che spiega in modo teorico il funzionamento della CPU. Il modello schematizzato risulta essere: Video: i dati vengono trasformati in segnali della scheda video. I segnali accendono i led. BUS : collegamenti elettrici che fanno comunicare fra loro le diverse parti del PC. È un dispositivo elettrico su cui viaggiano le informazioni. Memoria : lista di byte numerati che vengono variati dalla CPU. RAM : random access memory. Memoria volatile, utilizzata solamente per contenere dati e programmi in esecuzione. CPU : esegue in modo continuativo, secondo il modello di Neumann. È composta da diverse parti:
- ALU : arithmetic logic unit. Esegue computazioni aritmetiche attraverso i registri che hanno un numero finito di bit.
- PROGRAM COUNTER : numero che designa da dove la CPU andrà a leggere le istruzioni. All’accensione della macchina sarà 0.
- REGISTRO ISTRUZIONI : luogo dove vengono caricate le istruzioni che la CPU deve eseguire. I registri, solitamente, si indicano con $0, $1, … FETCH : preleva l’istruzione da eseguire dalla RAM dopo aver guardato il valore nel COUNTER, l’istruzione è memorizzata nel REGISTRO ISTRUZIONI.
DECODE : decodifica l’istruzione da eseguire. EXECUTE : la ALU esegue l’istruzione. CICLO DELLA VITA DI UN SOFTWARE In parole:
- Ho un’esigenza che va rivolta mediante un applicativo
- Valuto la fattibilità dell’applicativo
- Vengono fatte delle analisi specifiche
- Viene progettato e sviluppato il software
- Testing e, in caso questo non vada a buon fine, debugging. Il testing consiste nell’uso del software con diversi valori. Può dare falsi positivi e non falsi negativi. Verifica il funzionamento del programma.
- Dal testing/debugging torno alla progettazione se il bug non è risolvibile.
- Se non ci sono problemi viene rilasciato il software prima in privato e poi per il pubblico.
- Una volta rilasciato sono possibili della analisi specifiche.
- Una volta rilasciato è necessaria una continua manutenzione poiché gli utenti utilizzeranno il programma.
fmt.Print(“Quante volte? ”) fmt.Scan(&n) for i = 0; i < n; i++ { fmt.Println(“Ciao”) } } Usare “go fmt” per formattare un po’ il codice e renderlo più ordinato e leggibile. Per mettere le variabili scrivere “var” seguito dalle variabili che si vogliono e dal tipo di variabile (es. int = intero). Println = stampa e va a capo Print = stampa e basta Per ripetere una cosa a ciclo ripetuto n volte si scrive: Es. for i = 0; i < n; i++{ fmt.Println(“Ciao”, i) } Che significa: parti da 0, per ogni i < n (valore di n impostato prima), ripeti il ciclo aumentando sempre i di 1 (i++). Quando il valore di i = n interrompi il ciclo. Tutti i linguaggi di programmazione moderni iniziano a contrare da 1, non da 0. I ; possiamo non metterli perché il compilatore li mette per noi. Una volta compilato il programma bisogna vedere che la semantica del programma sia corretta. Es. se voglio che una cosa sia ripetuta 3 volte devo scrivere < n. se invece scrivo <= n la cosa mi verrà ripetuta 4 volte, non 3. Il programma funziona comunque, ma il problema è che non fa quello che volevamo noi, c’è un errore di semantica. Esempio di loop infinito: for i = 0; i = i; i++ { fmt.Print(“Ciao mamma” ) } Per bloccare un programma bisogna usare Control+C Le istruzioni vengono eseguite in ordine sequenziale. Con lo Scan il processo si interrompe e aspetta che si inserisca un dato. Es.
package main import “fmt” func main () { var n, m int fmt.Print(“Primo numero? ”) fmt.Scan(&n) fmt.Print(“Secondo numero? ”) fmt.Scan(&m) fmt.Println (n*m) } Questo serve per far inserire all’utente due numeri e poi dare come risultato il prodotto dei due numeri. Sulla schermata compare l’istruzione, poi il programma si blocca e aspetta che venga inserito il dato. Una volta inserito riparte con la seconda istruzione e richiede di inserire il secondo dato. Una volta fatto il tutto compare il prodotto dei due dati inseriti.
o {}: singolarmente sono due token, ma vanno messe insieme per una regola di sintassi: ad ogni { deve corrispondere una }. o Var: dopo un var vanno scritte le variabili, seguite da un tipo (es. int = intero). È una locazione di memoria. In ogni istante ha un valore, che in principio è 0 e poi va assegnato. Non si può dichiarare due volte la stessa variabile in uno stesso blocco (cioè all’interno delle {} in cui è stata definita). Di regola una variabile va dichiarata e lasciata “attiva” per il minimo possibile di righe, questo vuol dire minimizzare la visibilità lessicale di una variabile, cioè il lexical scoping. In generale i nomi delle variabili devono essere esplicativi, ma usare nomi di variabili molto lunghi può essere scomodo, per questo la lunghezza di una variabile deve essere proporzionale alla sua visibilità lessicale, tuttavia più questa è grande più il nome deve essere lungo e significativo. Quando in un blocco più interno si dichiara una variabile che è già stata dichiarata in un blocco più esterno avviene lo shadowing (“oscuramento”) e la variabile alla quale ci si riferisce quando si usa la variabile denunciata due volte è quella scritta per ultima in quanto ha minor visibilità lessicale rispetto all’altra. Questa cosa è comunque sbagliata da fare perché sotto intende che ci si è scordati di aver già usato quella data variabile. Questi eventuali errori possono essere trovati tramite il comando “go vet”, che cerca nel programma eventuali errori non visualizzati in precedenza. Se lo si usa da solo non fa nulla, ma se lo si mette insieme a, ad esempio: “go vet -shadowstrict – shadow=true hello.go”
- Regole idiomatiche. LA STRUTTURA A PACCHETTI I pacchetti sono dei gruppi di file, fisicamente organizzati su disco in directory separate, il cui scopo è:
- Organizzare il codice: un programma da 1000000 di righe va diviso in moduli (ognuno specifico per un’azione). fmt è un pacchetto. Per accedere a qualche altra funzionalità in un altro pacchetto bisogna importarlo (es. import fmt) e poi dichiarare la funzione che si vuole utilizzare.
Per importare più cose non serve tutte le volte mettere import, ma basta scriverlo una sola volta e mettere una sotto l’altra le voci da importare tra “”. Es. import ( “fmt” “math” ) Per togliere un elemento importato, senza toglierlo davvero (cioè continuando ad avere i controlli del linguaggio) si mette davanti al pacchetto importato _ Es. _“math” var x, y, z int x = 1 y = 4 z = x + y Il := dice di prendere l’espressione messa a destra e di indovinare qual è il tipo di variabile che c’è a sinistra Es. X := 3 Il compilatore indovina che tipo di variabile è, in questo caso si tratta di una variabile int. Printf è un modo di stampare in cui, con una stringa di codice, si definisce il formato. Es. fmt.Printf(“%T\n”, x) Stampa il tipo di variabile di x, non il valore. Es. fmt.Printf(“%d\n”, x) Stampa il decimale di x. Se scriviamo, ad esempio: Es. import ( “fmt”
CONTROLLI DI FLUSSO
Istruzioni che possono alterare la locazione di memoria, nel linguaggio macchina. Sono istruzioni strutturate che dividono il programma in blocchi logici. Casi:
- Sequenza: delimitate da {}, le istruzioni contenute all’interno vengono eseguite in ordine.
- Selezione: es. binaria (vero o falso). Varia il comportamento del programma se il programma riceve comandi da programmi esterni.
- Interazione: un blocco di codice viene eseguito non una sola volta, ma più volte, di numero prefissato o no. SELEZIONE BINARIA (IF ELSE) Serve ad eseguire un pezzo di codice se la condizione è verificata. Viene introdotto da una parola chiave (if) e dopo deve comparire una condizione. Es. if x == 0 { } Si mettono due uguali per evitare il conflitto di valore di x. Quindi la struttura è: if condizione { serie di condizioni che verranno eseguita in sequenza solo se la condizione è vera } Es. func main (){ var x, r int Print(“Inserisci quadrato perfetto”) Scan (&x) Print(“Inserisci radice”) Scan (&r) if x == r*r { Println(“Giusto”) } } Spesso dopo la condizione (if) è seguita un’altra condizione (else), che va posto sulla stessa riga. Es.
func main() { var x, r int if COND { … } else { … } } Es. func main() { var x int Scan (&x) if x % 2 == 0{ Println (“Pari”) } else { Println (“Dispari”) } } Es. func main() { var a, b, c, d int Scan (&a, &b, &c, &d) if da < cb{ Println (“a/b è minore di c/d”) } else { Println (“a/b è maggiore o uguale di c/d ”) } } Si può anche scrivere “else if” come condizione blocco, basta che l’ultimo “else” non ha “if”. Es. func main() { var a, b, c, d int Scan (&a, &b, &c, &d) if da < cb{ Println (“a/b è minore di c/d”) } else if da == cb { Println (“a/b è uguale a c/d ”) } else { Println (“a/b è maggiore di c/d”) } }
Scan (&x) !(a && b) == !a || !b !(a || b) == !a && !b if x < 0 || x > 2 { Println (“Compreso tra 0 e 2”) } else if x < 0 { Println (“x minore di 0 ”) } else { Println (“x maggiore di 2”) } } Es. func main() { var x int Print (“Inserisci due date di nascita:”) Scan (&a, &b) if a < b { Println (“Il primo è più vecchio”) } else if a == b { Println (“Stessa età ”) } else { Println (“Il primo è più giovane”) } } Es. import ( “fmt” “math” ) func main() { var a, b, c float Print (“Inserisci I tre coefficenti:“) Scan (&a, &b, &c) Δ := bb – 4ac if Δ > 0 { Println (“Due soluzioni reali:”) (-b + math.Sqrt(Δ))/(2a), (-b – math.Sqrt(Δ))/(2a) } else if Δ == 0 { Println (“Una soluzione reale: ”) (-b/(2a)) } else { Println (“Due coluzioni complesse”)
Es. import ( “fmt” “math” ) func main() { var n int = 5 var x int Print (“Tenta“) Scan (&x) if x == n { Println (“Azzeccato!”) } else { Print (“Tenta di nuovo“) Scan (&x) if x == n { Println (“Ci hai messo un po’, ma Ok!”) } else { Print (“Ultima speranza“) Scan (&x) if x == n { Println (“Fiuuu”) } else { Println (“Capra”) } }
