Operatori Aritmetici
Operatori aritmetici in Go
Gli operatori aritmetici permettono di eseguire calcoli matematici sui valori numerici. Go supporta cinque operatori aritmetici di base, oltre agli operatori di incremento e decremento.
I cinque operatori di base
Addizione (+)
L’operatore + esegue la somma tra due numeri. Funziona anche per la concatenazione di stringhe:
package main
import "fmt"
func main() {
a := 15
b := 7
somma := a + b
fmt.Println("15 + 7 =", somma) // 22
// Funziona con float
x := 3.14
y := 2.86
fmt.Println("3.14 + 2.86 =", x+y) // 6
// Concatenazione di stringhe
nome := "Ciao" + " " + "Mondo"
fmt.Println(nome) // Ciao Mondo
}
Sottrazione (-)
L’operatore - esegue la sottrazione tra due numeri:
package main
import "fmt"
func main() {
a := 20
b := 8
differenza := a - b
fmt.Println("20 - 8 =", differenza) // 12
// Risultato negativo
fmt.Println("8 - 20 =", b-a) // -12
// Negazione unaria
c := 42
fmt.Println(-c) // -42
}
Moltiplicazione (*)
L’operatore * esegue la moltiplicazione:
package main
import "fmt"
func main() {
a := 6
b := 7
prodotto := a * b
fmt.Println("6 * 7 =", prodotto) // 42
// Con float
prezzo := 19.99
quantita := 3.0
totale := prezzo * quantita
fmt.Printf("Totale: %.2f\n", totale) // Totale: 59.97
}
Divisione (/)
L’operatore / esegue la divisione. Il comportamento dipende dal tipo degli operandi:
package main
import "fmt"
func main() {
// Divisione intera: il risultato e troncato
a := 17
b := 5
fmt.Println("17 / 5 =", a/b) // 3 (non 3.4!)
fmt.Println("-17 / 5 =", -a/b) // -3
// Divisione decimale
x := 17.0
y := 5.0
fmt.Println("17.0 / 5.0 =", x/y) // 3.4
// Per ottenere un risultato decimale da interi
risultato := float64(a) / float64(b)
fmt.Printf("17 / 5 (float) = %.2f\n", risultato) // 3.40
}
Modulo (%)
L’operatore % restituisce il resto della divisione intera. Funziona solo con tipi interi:
package main
import "fmt"
func main() {
fmt.Println("17 %% 5 =", 17%5) // 2
fmt.Println("20 %% 4 =", 20%4) // 0
fmt.Println("15 %% 7 =", 15%7) // 1
// Il segno del risultato segue il segno del dividendo
fmt.Println("-17 %% 5 =", -17%5) // -2
fmt.Println("17 %% -5 =", 17%-5) // 2
// Uso pratico: verificare se un numero e pari
numero := 42
if numero%2 == 0 {
fmt.Println(numero, "e pari")
} else {
fmt.Println(numero, "e dispari")
}
}
Incremento e decremento
Go supporta gli operatori ++ e --, ma con una differenza importante rispetto ad altri linguaggi: sono istruzioni, non espressioni. Non possono essere usati all’interno di altre espressioni.
package main
import "fmt"
func main() {
contatore := 0
contatore++ // incrementa di 1
fmt.Println(contatore) // 1
contatore++ // incrementa di 1
fmt.Println(contatore) // 2
contatore-- // decrementa di 1
fmt.Println(contatore) // 1
// ERRORE: non sono espressioni
// x := contatore++ // Non compilera
// fmt.Println(contatore++) // Non compilera
// ERRORE: non esiste la forma prefissa
// ++contatore // Non compilera
}
Questa scelta progettuale elimina le ambiguita e gli errori comuni legati a espressioni come i++ + ++j presenti in linguaggi come C.
Divisione intera
La divisione intera in Go tronca sempre verso lo zero:
package main
import "fmt"
func main() {
// Divisione tra interi positivi
fmt.Println(7 / 2) // 3
fmt.Println(10 / 3) // 3
fmt.Println(1 / 3) // 0
// Divisione con numeri negativi (tronca verso zero)
fmt.Println(-7 / 2) // -3
fmt.Println(7 / -2) // -3
fmt.Println(-7 / -2) // 3
// Attenzione: divisione per zero causa un panic a runtime
// fmt.Println(10 / 0) // panic: runtime error: integer divide by zero
}
Per ottenere la divisione con arrotondamento verso l’alto (ceiling division):
package main
import "fmt"
func divisioneConArrotondamento(a, b int) int {
return (a + b - 1) / b
}
func main() {
fmt.Println(divisioneConArrotondamento(7, 2)) // 4
fmt.Println(divisioneConArrotondamento(10, 3)) // 4
fmt.Println(divisioneConArrotondamento(6, 3)) // 2
}
Ordine delle operazioni
Go segue le regole matematiche standard per la precedenza degli operatori:
- Parentesi
()- massima precedenza *,/,%- moltiplicazione, divisione, modulo+,-- addizione, sottrazione
package main
import "fmt"
func main() {
// Senza parentesi: moltiplicazione prima dell'addizione
risultato1 := 2 + 3*4
fmt.Println("2 + 3 * 4 =", risultato1) // 14
// Con parentesi: l'addizione viene eseguita prima
risultato2 := (2 + 3) * 4
fmt.Println("(2 + 3) * 4 =", risultato2) // 20
// Esempio complesso
risultato3 := 10 + 20*3 - 50/5
fmt.Println("10 + 20*3 - 50/5 =", risultato3) // 60
// Equivale a: 10 + (20*3) - (50/5) = 10 + 60 - 10 = 60
}
Esempio pratico: calcolatrice
package main
import "fmt"
func main() {
var a, b float64
var operatore string
fmt.Print("Inserisci il primo numero: ")
fmt.Scan(&a)
fmt.Print("Inserisci l'operatore (+, -, *, /): ")
fmt.Scan(&operatore)
fmt.Print("Inserisci il secondo numero: ")
fmt.Scan(&b)
var risultato float64
var errore string
switch operatore {
case "+":
risultato = a + b
case "-":
risultato = a - b
case "*":
risultato = a * b
case "/":
if b == 0 {
errore = "impossibile dividere per zero"
} else {
risultato = a / b
}
default:
errore = "operatore non valido"
}
if errore != "" {
fmt.Println("Errore:", errore)
} else {
fmt.Printf("%.2f %s %.2f = %.2f\n", a, operatore, b, risultato)
}
}
Conclusione
Gli operatori aritmetici di Go sono semplici e prevedibili. I cinque operatori di base (+, -, *, /, %) coprono tutte le operazioni matematiche fondamentali. La scelta di rendere ++ e -- istruzioni anziche espressioni elimina una classe intera di bug. La divisione intera tronca verso zero, e la precedenza degli operatori segue le convenzioni matematiche standard. Queste regole chiare rendono il codice aritmetico in Go facile da leggere e da prevedere.