Variabili e tipi

Una scatola con un’etichetta

Un programma che stampa sempre la stessa frase non è molto utile. Per fare qualcosa di interessante deve ricordare dei valori e lavorarci sopra. Il posto dove un programma ricorda le cose si chiama variabile.

Immagina una scatola con un’etichetta. L’etichetta è il nome, dentro c’è il valore, e la forma della scatola è il tipo: una scatola per numeri interi non può contenere del testo.

int age = 34;

Leggila così: “creo una scatola di tipo int (numero intero), la chiamo age, e ci metto dentro 34”. Da questo momento, ogni volta che scrivi age nel codice, il programma usa quel valore.

import std::io;

fn void main()
{
	int age = 34;
	io::printn(age);
	age = 35;          // change the box's contents
	io::printn(age);
}

34
35

Nota la seconda assegnazione: age = 35; senza int davanti. Il tipo si dichiara una volta sola, quando la variabile nasce. Dopo, si usa solo il nome. (Scrivere int age = 35; una seconda volta sarebbe un errore: “variabile già dichiarata”.)

Zero di default

Cosa c’è in una variabile appena creata, se non le assegni niente?

int counter;
io::printn(counter);

0

In C3 le variabili nascono azzerate. Sempre. Sembra ovvio, ma non lo è affatto: in C una variabile locale non inizializzata contiene spazzatura (qualsiasi cosa ci fosse in quella zona di memoria prima), ed è la fonte di una quantità impressionante di bug. C3 ha chiuso la porta a questa categoria di errori.

I tipi numerici interi

int è il tipo intero “normale”: 32 bit, quindi va da circa −2 miliardi a +2 miliardi. Basta quasi sempre. Quando non basta, ci sono i suoi fratelli:

E per ogni tipo con segno esiste il gemello senza segno (solo positivi, ma con il doppio dello spazio in alto): uint, ulong, ushort, char, uint128.

Sì, hai letto bene: char in C3 è un intero senza segno a 8 bit (0…255). Si chiama così per tradizione, perché un byte è spesso usato per rappresentare un carattere, ma il compilatore lo tratta come un numero. Ci torniamo tra poco.

Scrivere i numeri

Un numero scritto nel codice si chiama letterale. C3 ne accetta parecchie forme:

int decimal = 1_000_000;   // the underscore is ignored: it's just for readability
int hex = 0xFF;            // 255, base 16
int binary = 0b1010;       // 10, base 2
int octal = 0o755;         // 493, base 8
long big = 3_000_000_000;  // doesn't fit in an int, but does in a long

I trattini bassi sono un regalo: 1_000_000 si legge al volo, 1000000 no.

I numeri con la virgola

Per i numeri decimali (con la virgola, che nel codice è un punto) ci sono due tipi:

double pi = 3.14159;
double avogadro = 6.022e23;   // scientific notation: 6.022 × 10²³
float weight = 72.5f;         // the f suffix says "this is a float"
double int_as_double = 7;     // an int can become a double with no problem

Vero o falso: bool

Il tipo bool ha solo due valori possibili: true e false. Sembra poco, ma è il tipo con cui il programma decide: “l’utente ha vinto?”, “il file esiste?”, “il numero è pari?“.

bool is_raining = true;
bool has_umbrella = false;
io::printn(is_raining);

true

Vedremo nella prossima lezione che i confronti (5 > 3) producono proprio un bool, e nel Modulo 2 che if lo usa per scegliere quale strada prendere.

Testo: String

Il testo si tiene in una String:

String name = "Ada";
io::printn(name);
io::printn(name.len);

Ada
3

.len è la lunghezza della stringa, cioè quanti byte contiene. (Per il testo con accenti la faccenda è più sottile: "caffè" ha 6 byte, non 5, perché la è ne occupa due in UTF-8. Ci torneremo; per ora usa .len su testo semplice.)

Dentro le virgolette puoi usare delle sequenze di escape, che iniziano con \:

io::printn("Line one\nLine two");
io::printn("They said: \"hi\"");

Line one
Line two
They said: "hi"

Se gli escape ti danno fastidio (percorsi Windows, espressioni regolari), esistono le stringhe grezze tra apici inversi, dove \ è solo una barra:

String path = `C:\Users\ada\file.txt`;

Un singolo carattere: char

Un carattere tra apici singoli, 'A', è un letterale di tipo char. E come abbiamo detto, char è un numero: 'A' vale 65, secondo la tabella ASCII che assegna un numero a ogni simbolo.

char letter = 'A';
io::printn(letter);
io::printfn("%c", letter);

65
A

La seconda riga usa printfn con %c, che dice “trattalo come carattere, non come numero”. Impareremo printfn per bene nella lezione 6; per ora ti basta il concetto: un char è un byte, e come lo stampi dipende da te.

Costanti: valori che non cambiano

Alcuni valori non devono mai cambiare durante l’esecuzione: il numero massimo di giocatori, la velocità della luce, l’IVA. Per questi c’è const:

const int MAX_PLAYERS = 4;
const double VAT = 0.22;
const GAME_NAME = "Briscola"; // the type can be omitted: it's inferred from the value

Le costanti si scrivono in MAIUSCOLO_CON_TRATTINI. Non è un vezzo: è una regola del linguaggio, e il compilatore rifiuta const int max = 4;. Il vantaggio è che, leggendo il codice, sai a colpo d’occhio cosa è una costante e cosa no.

Provare a modificarla è un errore di compilazione:

MAX_PLAYERS = 5; // error: you can't assign to a constant

Le regole dei nomi

C3 è severo sui nomi, e questa severità è un dono: guardando un nome sai cos’è.

In tutti i casi: solo lettere a-z, A-Z, cifre 0-9 e _. Niente accenti, niente spazi, e non si può iniziare con una cifra.

Lo stile raccomandato (non obbligatorio, ma usato dalla libreria standard) è snake_case per variabili e funzioni: user_name, non userName. In questo corso seguiamo lo stile della libreria standard.

Una dichiarazione alla volta

Un’ultima differenza dal C, piccola ma che evita malintesi: ogni variabile ha la sua riga.

int a, b = 4;  // error in C3: what value does a have?

int a;
int b = 4;     // now it's clear

Mettiamo tutto insieme

import std::io;

const int CURRENT_YEAR = 2026;

fn void main()
{
	String name = "Ada";
	int birth_year = 1815;
	double height = 1.65;
	bool is_programmer = true;
	char initial = 'A';

	int age = CURRENT_YEAR - birth_year;

	io::printn(name);
	io::printn(age);
	io::printn(height);
	io::printn(is_programmer);
	io::printfn("%c", initial);
}

Ada
211
1.650000
true
A

Hai notato 1.650000? Quando stampi un double con printn, C3 usa sei cifre decimali. Nella lezione 6 vedremo come scegliere quante cifre mostrare.

Guarda la riga int age = CURRENT_YEAR - birth_year;: il valore iniziale di una variabile può essere un calcolo, non solo un numero scritto a mano. È il ponte verso la prossima lezione.

import std::io;

fn void main()
{
	String animal = "Dog";
	int dog_age = 7;
	int human_age = dog_age * 7;
	bool is_vaccinated = true;

	io::printn(animal);
	io::printn(dog_age);
	io::printn(human_age);
	io::printn(is_vaccinated);
}

Ricapitolando

• Una variabile è una scatola con un nome, un tipo e un valore: int age = 34;.
• Le variabili nascono azzerate. Sempre.
• Interi: int (default), long (grandi), char (un byte senza segno). Decimali: double (default), float.
• Da intero a decimale si passa gratis; il contrario richiede un cast (int).
• bool è true o false. String è testo tra virgolette. 'A' è un char, cioè un numero.
• const per i valori fissi, in MAIUSCOLO.
• Nomi: minuscola per variabili e funzioni, Maiuscola per i tipi, MAIUSCOLO per le costanti.

Prossima lezione: facciamo i conti. Somme, divisioni (con una trappola famosa), confronti e le regole di precedenza che C3 ha cambiato rispetto al C.