Scarica Programmazione I(linguaggio Go) Alberto Ceselli e più Appunti in PDF di Programmazione Avanzata solo su Docsity!
- PROGRAMMAZIONE 1................................................................................................................................................................................ Sommario
- Lezione 29/09 Introduzione
- Lezione 30/09 Turing – Von Neumann
- Lezione: 04/10/2022 Register Machine
- Lezione 06/10/2022 Dati di ingresso
- Lezione: 07/10/2022 Introduzione variabile
- CODICE INIZIALE:
- Lezione: 10/10/2022 Errori di codice...............................................................................................................................................
- Lezione 11/10/2022 Caratteristiche delle variabili
- Lezione: 13/10/2022 Costanti
- Lezione: 14/10/2022 Astrazione di processo
- Lezione del 18/10/2022 Ciclo di vita del software..........................................................................................................................
- Ciclo di vita del software:
- Lezione 20/10/2022 Controllo del flusso(if - for)
- Lezione 21/10/2022 I sottoprogrammi
- Chiamate delle variabili nei sottoprogrammi:
- Come passo i valori ai sottoprogrammi:
- Ruolo logico dei parametri:
- MANIPOLAZIONE DI VARIABILI TRA FUNC MAIN E FUNC CHIAMATA:
- Codici quiz.............................................................................................................................................................................................
- Inferenza assegnazione - dichiarazione
- Lezione Select Case
- Rappresentazione in varie basi
- Puntatori
- Lezione Conversione da decimale a binario
- Bitwise
- Tipi Unicode...................................................................................................................................................................................
- Tipi Rune
- Tipi String
- Codifica UNARIA:
- String
- Letterali RUNE:
- Letterali STRING:..................................................................................................................................................................................
- Lezione 20 : 16.11 Rune con stringhe
- Lezione 21 – Tipi di dato composti
- I Puntatori:
- I Puntatori
- Mappe
- Iterazioni dei vari tipi, per cicli for
- CONFRONTO TRA SLICE E MAPPE:
- Tipo Struct......................................................................................................................................................................................
- Definizione nuovi tipi......................................................................................................................................................................
- Metodo di ricorsione
2
PROGRAMMAZIONE 1
1) Lezione 29/09 Introduzione
Le prime macchine per il calcolo: abaco(concettualmente parlando) e Different Engine(Babbage 1833), venivano utilizzate per svolgere funzioni ARITMETICHE ; I Computer ➔ macchine per il calcolo; Correlazione: ASTRONOMIA → con i telescopi = INFORMATICA → con i computer; Konrad Zuse uno dei primi che realizzò la Z4, macchina per configurare e svolgere funzioni , utilizzando una logica di vettori: A +1 A V 4 5 S 1.n 1.n Nr interi di n bit E. Dijkstra → interpretò il comportamento del PC = traduzione, dal quale nacquero i linguaggi di programmazione.
2) Lezione 30/09 Turing – Von Neumann
La macchina di Turing è un esempio di modello di calcolo astratto (modello teorico di hardware o software, in grado di eseguire operazioni, memorizzarne il risultato e seguire il flusso dell'algoritmo) che utilizza architetture reali , che sono utili avendo pochi elementi formali, contenente celle nelle quali inserire dati , avendo un nastro infinito. La macchina di Von Neumann invece ha una memoria prefissata (non infinita) che indica lo stato della macchina e conteneva una CPU , ovvero un processore avente istruzioni che si svolgono in sequenza: Quindi ha una memoria che controlla lo stato della macchina e una CPU divisa in due parti, la ALU ovvero l’Unità Logico - Aritmetica, utilizzata per sommare, elevare, calcoli aritmetici e la CU ovvero l’unità di Controllo che serviva per attivare e disattivare i collegamenti per mettere in funzione la ALU. Per programmare è necessario avere un programma con delle istruzioni con vari collegamenti che permettano di fare delle specifiche operazioni; Es. SOMMA = serie di circuiti da aprire e chiudere per permettere di sommare delle celle; Quindi i passi da fare sono: 1) costruire la macchina, 2) scrivere in memoria dati e istruzioni, 3) macchina lavora e da l’output; Un esempio reale: Assembly MIPS 32 , nella quale creo un insieme di istruzioni (pre-settate) che usino un linguaggio specifico , in questo caso l’Assembly language; Es. La funzione ADD serve per sommare i dati inseriti (questo viene specificato nel momento della programmazione del linguaggio stesso/della macchina); La programmazione di queste macchine permette di costruire qualcosa per poi utilizzarlo a legare diverse celle con dati e istruzioni; Il funzionamento della macchina = prevede l’interazione tra un registro, una CPU e il Program Counter: Se A è un vettore = A[4]+
In questo pezzo di codice l’obiettivo era quello di creare una funzione che mi permettesse di saltare 4 da un’azione a un’altra, qualora il contenuto di una cella sia uguale a 0 :
- Per prima cosa creo un registro arbitrario e uno di supporto, così da modificare solo quello su cui voglio fare azioni;
- Dopo di ché genero un’etichetta chiamata J per indicare l’insieme di azioni da fare per saltare alle istruzioni dopo quando arrivo ad ottenere zero;
- Utilizzo BEGIN → per indicare l’inizio dell’azione, partendo dall’incremento del registro di supporto;
- Scrivo JNZ che mi permette di controllare il registro “Rh” e guardare l’etichetta per poi saltare alla prossima azione quando non è zero il valore;
- Concludo le azioni da fare in J con END; Genero un’altra etichetta che sarebbe JZ(Jump Zero), che guarda il registro Ra e lo etichetto :
- Inizio con BEGIN per introdurre JNZ se il valore del registro “Ra” sia un valore diverso da 0, se è così va all’END(fine dell’azione);
- Se non fosse così utilizzerei l’etichetta J(Jump) per andare a fare le azioni indicate prima, questo quando il valore è 0. In questo pezzo di codice invece si vuole azzerare il registro :
- Inizio a chiamare un’etichetta con la parola RESET nel registro (Ra);
- Inizio con BEGIN 3 e decremento il registro(Ra);
- Se il registro non è uguale a 0, allora torna a BEGIN 3 per ripetere l’azione fino ad ottenerlo azzerato, per poi andare all’END. In questo pezzo di codice si vuole invece copiare il valore di un registro in un altro, da Ra a Rd:
- Chiamo l’etichetta COPY e indico i 2 registri di riferimento (in Rd da Ra);
- Inizio con BEGIN4 nel quale richiamo l’azione REST (codice precedente), per azzerare Rd, ovvero il registro in cui devo incollare il nuovo dato;
- P1 mi introduce le varie azioni da fare, JZ se il valore è azzerato posso inserire il nuovo e così concludo subito END4;
- Altrimenti incremento il Registro Ra e decremento Rd per poi riandare con Jump a P1 e ripetere le azioni, come un ciclo;
5 Nel seguente codice si vuole calcolar e la somma di 2 numeri, Ra + Rb e metterli all’interno di Rd: Per prima cosa azzero Rd (ovvero il registro in cui inserisco la somma); Uso la funzione INC per incrementare Ra con il valore di Rb; Ora avrò la somma di Ra e Rb all’interno di Ra , quindi uso la funzione COPY(creata sopra) per inserirla in Rd. Programmiamo la complessità : analizziamo il quesito e organizziamo un processo per aiutare l’utente , con le istruzioni assembly teoricamente è possibile, ma è impercorribile, su utilizza quindi:
- Procedimento TOP DOWN ➔ potrei utilizzare un insieme più grande di istruzioni, è uno stile di programmazione in cui la progettazione inizia specificando parti complesse e suddividendole successivamente in parti più piccole ; La traduzione dai linguaggi di programmazione ad alto livello → fino alla macchina (quindi basso livello ), procediamo usando un SOFTWARE , (macchina di Touring, Random Machine ecc … potrebbero essere configurate bene per diventare dei veri e propri traduttori) COMPILATORI ; Per andare da un linguaggio di alto livello → alle istruzioni della macchina , si possono usare 2 mediatori: INTERPRETI = fanno la traduzione istruzione per istruzione (se c’è un errore si ferma e non riparte finché non si sistema); Il programma (pitch.nyq), i dati(file.wav), le librerie entrano tutte in macchina virtuale e vengono tradotte man mano, dalla quale esce in output l’esecuzione( detection): Dal sorgent e all’esecuzione:
- Avviene l’editing del codice sorgente , riga dopo riga per poi avere un run simultaneo (hello.py); COMPILATORI = prendono tutte le istruzioni di un programma e fanno la traduzione tutta insieme (se c’è un errore nel codice si blocca tutta la traduzione) ; Il programma(HELLO.GO) analizza il lessico e la sintassi , genera un codice intermedio (che ottimizza il tutto), genera a sua volta un codice oggetto (HELLO.O) con il quale scriverò nelle librerie (codici scritti da altri programmatori, condivisi ad altri programmatori per utilizzare altre funzioni) (linker) per permettermi di eseguire i dati ➔ fase di esecuzione (HELLO.EXE); Dal sorgente all’eseguibile, per ottenere un’applicazione:
- Si parte con l’EDITING del codice sorgente (codice vero e proprio)
- Crea il codice di testo che passa al compilatore per creare il codice oggetto ( COMPILE TIME ) hello.go;
- Creazione eseguibile alla libreria ( LINKING TIME ) hello.o;
- Nell’ultimo momento c’è l’esecuzione , l’eseguibile viene preso dal disco e fatto eseguire ( RUN TIME ) hello.exe;
7
CODICE INIZIALE:
Pattern_0 ➔ struttura minimale che hanno tutti i programmi Go; è già un sorgente Go eseguibile , come se “invocassi” il compilatore Import “fmt” ➔ per utilizzare delle librerie , solitamente “fmt” (dico al linker go le librerie da prelevare); Fmt.Println → significa che la println (print line) sta all’interno dell’istruzione fmt; fmt.Println(“Hello World”); Var valore_da_calcolare int → per dichiarare ed introdurre l’utilizzo di una variabile ( var = parola chiave) tramite un indicatore ( valore_da_calcolare ) e gli do il tipo della variabile( int ), per marcare la variabile; I VARI MOMENTI DI UNA VARIABILE Allocazione ➔ la variabile inizia ad avere una corrispondente in memoria, per poi perderla nella fase di Rilascio
- Dichiarazione = introduco la variabile, dandogli un nome e il tipo del valore (var Nome Int);
- Definizione (inizializzazione/allocazione) = nella dichiarazione viene introdotta ma anche allocato il valore (è in linea con la dichiarazione);
- Utilizzo = indica il momento in cui uso propriamente la variabile per fare il mio problema;
- Rilascio = nel momento in cui stampo la variabile, rilascio il valore (fmt.println);
6) Lezione: 10/10/2022 Errori di codice
Esistono regole che il compilatore mette e avvisa il programmatore cosa non va bene, e si suddividono su diversi livelli: Se sbaglio a scrivere:
- Lessicale = definisce regole sulla combinazione dei simboli che possono produrre elementi base del linguaggio che siano validi, sulla composizione di sequenze di simboli (token) I Token → ad esempio: index, =, +, 2, possono essere di diverso tipo: o Keyword = var, …; o Identificatore = nome che do a dei valori, come le variabili (es. un identificatore non può partire con una parentesi…); o Separatori o Operatori = simboli che specificano una determinata azione (+, - , / …); o Letterali(costanti) Se sbaglio l’ordine con il quale scrivo:
- Sintattico = quali operazioni base (token) del linguaggio, che sono lessicalmente validi, producono delle espressioni che siano valide : 1 ) Pattern_
8 o Quando ho un assegnamento, devo avere a sinistra un identificatore e a destra un’espressione valutabile; Se sbaglio ad esprimere un concetto:
- Semantico = definisce delle regole per associare alle istruzioni un significato, ad esempio l’utilizzo corretto dei tipi delle variabili (var numero string = è sbagliato semanticamente);
- Pragmatico/Estetico = per la distribuzione del testo (indentazione), sbaglio le spaziature, oppure come esprimo alcuni campi un po' storti. Regole imposte dal programmatore stesso.
7) Lezione 11/10/2022 Caratteristiche delle variabili
Le variabili hanno le seguenti caratteristiche:
- Identificatore (nome)
- Valore (assegnato dall’utente)
- Tipo (tipologia ad es. string, int…)
- Scope (motivo per usarlo)
- Indirizzo (in che cella si trovano) I tipi di base delle variabili:
- Bool (boolean) veri o falsi
- String
- Int int8 int16 int32 int64 indica i numeri dei bit nelle celle di memoria
- Byte //alias unit
- Rune //alias for int32 (unicode code point)
- Float32 float
- Complex64 complex I tipi U (U → unsigned =postivi), sono come interi ma possono essere solo senza segno perché si assume il segno +, da 0 in su; Gli operatori possono essere:
- Binari → due dati a confronto (*, /, +, - , >, …)
- Unari → un solo dato (- n, +n …) Se la versione è strong typing = significa che un’operazione tra 2 tipi diversi non può avvenire , si è obbligati ad usare variabili dello stesso tipo; Posso convertire i valori però, scrivo il tipo nuovo da dare alla variabile e poi scrivo la mia variabile [ int (b)], così assegno nuovo tipo alla variabile b , questa conversione è temporanea , ovvero dopo l’espressione nella quale ho utilizzato questa conversione, la variabile torna al tipo precedente ; a = 1 b = 7 a++ va scritto a parte e non direttamente nell’espressione da fare c = a/b INTEGER: I tipi interi sono associati ad una certa quantità di memoria che possono essere ad esempio 32 o 64 bit. Se so che una variabile occupa metà della memoria, posso decidere di utilizzare un byte o specificare quanti byte deve usare la variabile. Questo obbliga però il mio processore ad usare più istruzioni; perché generalmente vengono presi tutti bit della cella di memoria, quindi la macchina noverebbe prendere tutta la cella, decifrare quali sono i bit che gli interessano e poi riportare quello che manca nei registri, quindi non ne vale la pena. FLOAT: Float = codificano per i numeri reali , [esistono 2 tipi, in bas e all’architettura del pc (32 o 64)] Non tutte le conversioni sono possibili, ad esempio se voglio convertire da un intero a un float, il programmatore si aspetta che rimanga praticamente uguale, però se converto da un float a un intero, perdo la parte decimale (Go tronca, quindi anche se fosse ad esempio 3,7 → 3);
10 Vogliamo creare una tabella con i valori di a e b booleani, con le varie possibilità vero o falsi, e vedere come si comportano nella somma dei valori: stampa l'intestazione della prima riga: val.a , val.b, == poi assegna riassegna true o false a b / a e ti stampa il valore di a , valore di b , valore della loro somma nei vari casi (a e b si alternano di valore) \t ➔ serve per inserire uno spazio tra dei valori (qua lo metto per creare una tabellina) La tabella che si crea, facendo partire il file eseguibile è la seguente: Se con il comando go build esercizio.go → compila , vuol dire che non ci sono errori logici , e crea l’seguibile, però solo con l’eseguibile posso capire se funziona bene.
11 Solitamente si utilizzano tipi booleani all’interno di cicli, nei quali voglio confrontare dei dati, ad esempio: Voglio creare un programma che richieda all’utente di inserire un numero, se il valore inserito è maggiore di 10( if n > 10 ), allora il valore alla variabile b (b = true ) è vera, perciò entra nel if alla prima condizione e stampa ( if b { fmt.Println ( “Il valore inserito è maggiore di 10”) } , altrimenti va nell’ else e stampa { fmt.Println ( “Il valore inserito è minore di 10”) } Se volessi fare un test con degli operatori che non ci sono posso comporre quelli che già esistono. Le parentesi servono a dare un ordine di esecuzione, svolgo prima quello che c’è in parentesi; Le operazioni sono soggette a delle regole di precedenza: Regole di priorità Regole di associatività Le operazioni sui booleani, non sono le uniche che restituiscono risultati booleani, bensì ci sono altri tipi, che partono da tipi diversi di booleani e arrivano ad avere bool; Un operatore di confronto prende 2 operandi (2 nr, ad esempio interi) li confronta e ottiene un vero o falso, tipo < o > ;
13 Si vuole creare un programma che richieda all’utente un valore e il codice capisca se è positivo, nul lo o negativo. Creo un flowchart con 2 cicli If, il primo controlla se il valore è maggiore o uguale di zero, e all’interno di esso, richiedo se è maggiore di zero oppure uguale e in base al confronto stampo in output la soluzione, se la variabile non sodd isfa il primo if, stampo direttamente l’output, dicendo che il valore è negativo.
14 Ciclo For → è un ciclo iterativo, che permette di richiedere un’azione , quando la condizione è vera, altrimenti esce dal ciclo; Se non si verifica la condizione, allora esce dal ciclo for; Se si verifica, ovvero a è minore di zero, richiede con Scan(&a) il valore di a;
10)Lezione del 18/10/2022 Ciclo di vita del software
Voglio un programma che riceva in I un nr R e restituisca in O un messaggio: “pari” = se la prima cifra decimale è pari; “ dispari ” = se la prima cifra decimale è dispari; Metodo risolutivo: se avessi un intero, potrei calcolare il resto della divisione per 2 (operatore modulo % in GO): Tronca il numero: Se avessi come n = 77,64 → moltiplico per 10, n = 776,4 → tronca all’intero, n = 776 Infine, calcolo il resto della divisione per 2, se RESTO = 0, stampa pari; se RESTO ≠ 0, stampo dispari;
Ciclo di vita del software:
Analisi delle esigenze: per capire cosa serve progettare: Studio di fattibilità → (capire se è possibile da programmare); Stesura delle specifiche → vedere cosa scrivere in input e output; Progettazione: Sviluppo vero e proprio → dopo la codifica realizza il metodo che ho progettato; Testing e debugging → provare il programma, se il testing risponde bene siamo a buon passo e poi con il debugging sistemo i problemi; Rilascio → il software che ho scritto e lo porto al cliente; Uso , aggiornamento e manutenzione → lo utilizzo, aggiorno in base a cambiamenti e con il tempo magari il server cambia e quindi il programma può richiedere manutenzione; Dalla selezione ai cicli: Idea → si sviluppa su esempi di controllo dell’input , per verificare se ha senso la codifica proposta; Si parte da un costrutto di selezione if-then-else (esiste anche la versione senza else, + usata); Si rende poi il costrutto iterativo, ovvero valuta la condizione e vede cosa fare for condizione> e Si vuole creare un programma che richieda dei numeri in Input e restituisca in Output la somma finché non si digita il numero 0, che blocchi la richiesta di altri dati.
16
11)Lezione 20/10/2022 Controllo del flusso(if - for)
CONTROLLO DEL FLUSSO:
Costrutto 1 = sequenza Costrutto 2 = selezione binaria (If ,{then }else{}) Costrutto 3 = iterazione (For , , { istruzioni}) Ci sono 2 tipologie di utilizzo del FOR: Unario ➔ con una sola condizione di permanenza (es. For n < 10) Ternario ➔ con una terna di condizioni , inizializzazione del contatore(c=0), condizione del contatore(c<10), aggiornamento del contatore(c++); Si vuole creare un programma che inserisca in INPUT due interi positivi M e N e restituisca in OUTPUT i divisori comuni tra i 2 numeri: Progettazione : individuo il minore tra N e M (lo chiamo P) primo ciclo if; Itero: provo iterativamente tutti gli interi k (nuova variabile per vedere i divisori comuni) da 1 a P(non vado oltre al più piccolo perché sicuramente un numero più grande di P non può essere suo divisore) ciclo for ternario For k = 1; k <=P; k++ Per ognuno di questi k, controllo se k divide esattamente sia N che M, utilizzando l’operatore per restituire il resto delle divisioni (%); stampo k altrimenti non faccio nulla e passo all’altro numero (incrementando k). Per terminare il ciclo infinito ➔ Ctrl + C, interrompe tutto il programma, è una cosa da fuori che ferma i programmi che altrimenti andrebbero avanti all’infinito come dei loop.
17 Esistono 2 funzioni che influenzano il funzionamento del codice (vanno usate con parsimonia), sono break e continue che sono una l ’opposta dell’altra. La prima permette di fermare un loop, per andare in una determinata linea proposta, mentre la seconda serve per fare ripartire una determinata selezione (solitamente ciclo if, lo permette di far diventare come un ciclo for): BREAK = h a l’effetto di mandare fuori dal ciclo la prossima iterazione, quindi nel momento in cui l’utente arriva alla condizione connessa alla funzione “break”, va fuori dal ciclo for e va a riprendere le azioni dopo (è simile al JUMP di MIPS32); Il ciclo for che ho creato serve per richiedere all’infinito all’utente un numero, finche questo non digita 0 (momento in cui entra la funzione break) e salta alle righe di codice dopo. CONTINUE = continua a far iterare un ciclo if, fino a che la condizione rimane vera Utilizzo in primis un ciclo for per scansionare i vari numeri, per farli inserire da un utente, però potrebbe inserirli fino all’infinito finché non c’è un avvenimento scritto, ovvero: CONTINUE se inserissi un numero < 1(quindi negativo) il programma torna su all’iterazione precedente per richiedere un numero diverso (come se non prendesse in memoria il numero negativo); BREAK se inserissi uno 0, il codice termina il ciclo, si interrompe e mi restituisce il codice finale (in questo caso stampa la somma dei numeri precedentemente inseriti.
19 Il MAIN è un sottoprogramma speciale, perché funziona uguale. Il MAIN è il programma vero e proprio (cioè la parte principale). I sottoprogrammi dichiarati sopra vengono usati al suo interno attraverso il meccanismo della chiamata. Una chiamata di procedura può apparire in ogni punto dove potrebbe apparire uno statement, mentre una chiamata di funzione può apparire in ogni punto dove potrebbe apparire un'espressione del tipo corrispondente. Una chiamata = di un sottoprogramma è costituita dal nome del sottoprogramma e dagli elementi che istanziano i parametri (i cosiddetti parametri attuali).
Chiamate delle variabili nei sottoprogrammi:
Function call frame = è un record di attivazione dei sottoprogrammi , è una zona di memoria, attivata alla chiamata che contiene delle informazioni: VARIABILI LOCALI → Variabili definite nel sottoprogramma; Parametri dei sottoprogrammi (input e output) Altre informazioni per il controllo Il principio di località = dice che è meglio che ogni effetto del mio codice, funzioni sulla mia istruzione o nei pezzi di codice intorno, per evitare di “perdersi” tra le variabili ; Scope di variabili = luogo nel quale la variabile dichiarata, può essere utilizzata (regione della variabile locale); Il passaggio di parametri a sottoprogrammi, in input ho un valore, poi chiamo con il sottoprogramma la variabile(var tmp float) e ottengo in output il valore lavorato all’interno del sottoprogramma , quindi quelle che hanno seguito le istruzioni del sottoprogramma; Con RETURN = ottengo il controllo del programma iniziale, restituzione della variabile elaborata nel sottoprogramma;
Come passo i valori ai sottoprogrammi:
Vengono passati i dati in input per copia, quindi una volta che si fa una copia, la variabile iniziale diventa una variabile locale del sottoprogramma; Le inizializzo come variabili del sottoprogramma, potendole manipolare come variabili locali; Differenza tra variabili locali e di output, è che al momento del return, il valore del parametro di output, viene copiato, nell’istruzione del chiamante ;
Ruolo logico dei parametri:
Il Ruolo concettuale, nella testa di un programmatore un dato può essere Input, Output o Entrambi; Dal punto di vista meccanico invece, go usa strumenti per rendere possibili le esistenze di questi tipi di variabili, non mette una gestione diretta(come invece permette c++ per reference), quindi il meccanismo interno è per copia di parametri MECCANISMO DELLE VARIABILI:
- Se il meccanismo è di tipo Input e Output, quindi con 2 variabili separate, copia il valore nell’output;
- Se il meccanismo invece è Input-Output, lo modifica direttamente lì, cambiando il valore; Per capire il funzionamento devo separare il livello concettuale con quello meccanico;
20
MANIPOLAZIONE DI VARIABILI TRA FUNC MAIN E FUNC CHIAMATA:
La Function Call Frame serve per la memoria, per attivare i record dei sottoprogrammi; Così per fare nuove chiamate utilizzo sempre Function call frame, per chiamare altre funzioni, altri sottoprogrammi con le loro variabili; Al momento della chiamata, le variabili vengono copiate nelle variabili del sottoprogramma; Una volta che terminar il funzionamento del sottoprogramma, il Function call frame perde di valore , finisce, copia i valori dal Function call frame del chiamato al Function call frame del chiamante. Se ad esempio all’interno del sottoprogramma, viene chiamato un al tro programma, fa lo stesso passaggio sopra, che quindi va a copiare le informazioni nelle variabili locali del sottoprogramma appena chiamato ; Ogni Function call frame, ogni sottoprogramma ha delle variabili locali “nuove”, si chiamano uguali, ma hanno indirizzi diversi, e il valore, prendono quelle appena inserito nel programma chiamante; Le variabili locali = l ’indirizzo delle variabili locali, diventa noto, quando attivo la chiamata al sottoprogramma:
- Variabili del sottoprogramma;
Scope delle variabili:
Quando posso usare una variabile e quando no , se è in memoria posso usare la variabile,
- Scooping dinamico = agli occhi del programmatore è ingestibile , perché se deve pensare al programma in se e alle chiamate dei sottoprogrammi;
- Lo Scooping statico = restringe le possibilità di uso delle variabili , artificialmente, prevede la dichiarazione di variabili in punti diversi del programma , possono essere globali o locali al sottoprogramma o locali a blocchi di codici del sottoprogramma(in cicli ad esempio), una variabile la puoi usare, nel blocco in cui l’hai definita. BLANK VARIABLE Esiste una variabile che permette di eliminare i dati delle celle qual ora non fossero come vogliamo, contatore, _ = radice(dato_da_calcolare, denominatore) // _ : è BLANK VARIABLE ovvero cestino La BLANK VARIABLE devo metterla nella posizione che voglio buttare; In questo caso elimina il contenuto del secondo valore, ovvero non assegna valore nella posizione che metto _;
Codici quiz
Se guardo solo il main, penso che il programma stampi 4; Però è costruito male, poiché usa il nome uguale per 2 variabili: Quindi la prima a, viene inizializzata a zero (come tutte le variabili), e quindi la func double da output in res = 0, poi la inserisco nella principale, func main
