En aquest tema, explorarem els diferents tipus de dades que Rust ofereix. Rust és un llenguatge de programació fortament tipat, el que significa que cada variable té un tipus que es determina en temps de compilació. Això ajuda a evitar molts errors comuns i fa que el codi sigui més segur i eficient.
Tipus de Dades Bàsics
Tipus Escalars
Els tipus escalars representen un sol valor. Rust té quatre tipus escalars principals:
- Enter (Integer)
- Punt Flotant (Floating-Point)
- Booleà (Boolean)
- Caràcter (Character)
Enter (Integer)
Els enters són nombres sense part decimal. Rust suporta diversos tipus d'enters, que es diferencien per la seva mida i si són signats o no signats.
| Tipus | Mida | Rang |
|---|---|---|
i8 |
8 bits | -128 a 127 |
u8 |
8 bits | 0 a 255 |
i16 |
16 bits | -32,768 a 32,767 |
u16 |
16 bits | 0 a 65,535 |
i32 |
32 bits | -2,147,483,648 a 2,147,483,647 |
u32 |
32 bits | 0 a 4,294,967,295 |
i64 |
64 bits | -9,223,372,036,854,775,808 a 9,223,372,036,854,775,807 |
u64 |
64 bits | 0 a 18,446,744,073,709,551,615 |
isize |
Depèn de l'arquitectura | Depèn de l'arquitectura |
usize |
Depèn de l'arquitectura | Depèn de l'arquitectura |
Exemple:
Punt Flotant (Floating-Point)
Els tipus de punt flotant representen nombres amb part decimal. Rust suporta dos tipus de punt flotant:
| Tipus | Mida | Precisió |
|---|---|---|
f32 |
32 bits | Simple precisió |
f64 |
64 bits | Doble precisió |
Exemple:
Booleà (Boolean)
El tipus booleà té dos valors possibles: true i false.
Exemple:
Caràcter (Character)
El tipus char representa un caràcter Unicode. Cada char ocupa 4 bytes.
Exemple:
fn main() {
let c: char = 'z';
let z: char = 'ℤ';
let heart_eyed_cat: char = '😻';
println!("c: {}, z: {}, heart_eyed_cat: {}", c, z, heart_eyed_cat);
}Tipus Compostos
Els tipus compostos poden agrupar múltiples valors en una sola entitat. Rust té dos tipus compostos principals:
- Tuples
- Arrays
Tuples
Les tuples poden agrupar diversos valors de diferents tipus en una sola entitat. La mida d'una tupla és fixa.
Exemple:
fn main() {
let tup: (i32, f64, u8) = (500, 6.4, 1);
let (x, y, z) = tup; // Desestructuració
println!("x: {}, y: {}, z: {}", x, y, z);
}Arrays
Els arrays poden agrupar múltiples valors del mateix tipus en una sola entitat. La mida d'un array és fixa.
Exemple:
fn main() {
let a: [i32; 5] = [1, 2, 3, 4, 5];
let first = a[0];
let second = a[1];
println!("first: {}, second: {}", first, second);
}Exercicis Pràctics
Exercici 1: Declaració de Variables
Declara variables de diferents tipus de dades i imprimeix-les.
fn main() {
let a: i32 = 10;
let b: f64 = 3.14;
let c: bool = true;
let d: char = 'R';
println!("a: {}, b: {}, c: {}, d: {}", a, b, c, d);
}Exercici 2: Treballant amb Tuples
Crea una tupla amb tres elements de diferents tipus i desestructura-la per imprimir els seus valors.
fn main() {
let tup: (i32, f64, char) = (42, 6.28, 'R');
let (x, y, z) = tup;
println!("x: {}, y: {}, z: {}", x, y, z);
}Exercici 3: Treballant amb Arrays
Crea un array de cinc elements i accedeix als seus elements per imprimir-los.
fn main() {
let arr: [i32; 5] = [10, 20, 30, 40, 50];
for i in 0..arr.len() {
println!("arr[{}]: {}", i, arr[i]);
}
}Resum
En aquest tema, hem explorat els tipus de dades bàsics i compostos en Rust. Hem après sobre els tipus escalars com els enters, punts flotants, booleans i caràcters, així com els tipus compostos com les tuples i els arrays. Aquests conceptes són fonamentals per a la programació en Rust i ens ajudaran a construir programes més complexos en els següents mòduls.