# Note lezione (19/11/2020)
lezione precedente su wiki: https://sl-lab.it/dokuwiki/doku.php/pub:labprog:2020-11-12
wiki del lab: https://sl-lab.it/dokuwiki/doku.php/pub:labprog:home
link esercizi: https://forms.gle/vyNZJFHWCpb8RXjW9
link upload: https://upload.di.unimi.it/?id=2387
Attenzione a non sovrascrivere il testo esistente
## MEMO * scrivete tanto codice e fate saltar fuori gli errori * usate molto il prompt * non abbiate paura di fare domande (o scrivere commenti) * INDENTATE!!! (comando ```go fmt <nomeFile>```)
## FAQ ### Esercizio 1
La funzione ```rand.Intn(n int)``` ritorna un intero generato casualmente tra [0,n). Documentazione: https://golang.org/pkg/math/rand/ Nota (che non serve per questo esercizio in particolare): quando usate funzioni che devono generare qualcosa in modo pseudocasuale ricordatevi sempre di settare prima il seed: ``` rand.Seed(time.Now().UnixNano())``` Questa istruzione è necessaria, dal momento che se il seed non viene settato all'inizio, la sequenza di numeri generata sarà sempre la stessa ogni volta che lanciate il programma.
—
Ragionate sulla retta dei numeri per capire come modificare l'istruzione ```lancio := rand.Intn(7)``` per generare numeri nell'intervallo [1,6] invece che nell'intervallo [0,6]
In quali aspetti differiscono i due segmenti [0,6] e [1,6]? (Il secondo è più corto e inizia più a destra)
—
### Esercizio 2
Per la domanda “Di che tipo è la variabile data?” si intende quella nel main.
—
### Esercizio 3
Lo switch da riga 20 a 27 può e deve essere sostituito da una sola istruzione
—
Per stampare un ```%```: - con Printf scrivere ```fmt.Printf(“%%”)``` perché il primo argomento della printf è una STRINGA DI FORMATO che viene interpretata
Ecco cosa succede se non mettete entrambi i %: ```golang fmt.Printf(“print che fallisce a stampare il percentuale : %”) ``` ```shell ./prog.go:9:2: Printf format % is missing verb at end of string ``` Questo accade dato che dopo il ```%``` la printf si aspetta di dover interpretare qualcosa, ad esempio: ```fmt.Printf(“%d”, n)``` stampa un intero ```n```
- cont Println basta ```%```: ```fmt.Println(“%”)``` dal momento che nella println NON viene interpretato nulla
—
### Esercizio 4
L'esercizio non contiene errori. Una funzione eseguirà correttamente lo scambio, e l'altra no. Lo scopo dell'esercizio è farvi ragionare sul perchè una esegue lo scambio e l'altra fallisce.
—
### Esercizio 5
I significati dell'asterisco: - ``` n * m ``` con n e m numeri: è l'operatore per la moltiplicazione - altrimenti si riferisce a un puntatore
Contesti: ```golang package main
import “fmt”
la dicitura (x *int) significa che la funzione prende in input un puntatore ad un intero func StampaPuntatore(x *int) { fmt.Printf(“Valore del puntatore: %d\n”, *x) fmt.Printf(“Indirizzo di memoria di x: %x\n”, x) } func main() { x := 1 dichiaro un intero x
StampaPuntatore(&x) //passo come argomento l'indirizzo di memoria di x
} ``` Output: ``` Valore del puntatore: 1 Indirizzo di memoria di x: c000100010 ```
Proviamo ora a scrivere una funzione che modifica il valore di x:
```golang func modificaPuntatore(x *int, nuovoValore int){
- x = nuovoValore assegno nuovoValore a ciò che punta x (a cui mi riferisco con *x) } ``` Per invocare la funzione: ```modificaPuntatore(&x, <nuovoValore>)``` Non sarebbe andato a buon fine il seguente tentativo: ```golang func modificaSbagliata(x int, nuovoValore int){ non prende in input un puntatore ma un int
x = nuovoValore }
func main() {
x := 1 //dichiaro un intero x modificaSbagliata(x,3) //non do in input un puntatore ma un int StampaPuntatore(&x) //passo come argomento l'indirizzo di memoria di x
} ``` Output: ``` Valore del puntatore: 1 Indirizzo di memoria di x: c00002c008 ```
— La funzione ```newPunto``` deve restituire una variabile di tipo Punto avente come coordinate x e y passate in input alla funzione
—
Per modificare i campi di una struttura di cui abbiamo il puntatore:
```golang type Struttura struct{
campo int
}
func modificaCampo(s *Struttura, n int) {
(*s).campo = n
}
func main() {
s := Struttura{1}
modificaCampo(&s, 2)
fmt.Printf("%+v\n",s) // %+v stampa una struttura con tutti i suoi campi
}
``` Output: ``` {campo:2} ``` — ### Esercizio CIFRE
Per verificare se una carattere è una cifra potete usare la funzione
```unicode.IsDigit(r Rune)```
Documentazione: https://golang.org/pkg/unicode/#IsDigit
Per ottenere l'int corrispondete a una runa c che rappresenta una cifra:
c - '0'
—
.
