Rust - Tipi di dati

Il Type System rappresenta i diversi tipi di valori supportati dalla lingua. Il Type System verifica la validità dei valori forniti, prima che vengano memorizzati o manipolati dal programma. Ciò garantisce che il codice si comporti come previsto. Il Type System consente inoltre suggerimenti più ricchi sul codice e documentazione automatizzata.

Rust è un linguaggio tipizzato staticamente. Ogni valore in Rust è di un certo tipo di dati. Il compilatore può dedurre automaticamente il tipo di dati della variabile in base al valore ad essa assegnato.

Dichiara una variabile

Utilizzare il let parola chiave per dichiarare una variabile.

fn main() {
   let company_string = "TutorialsPoint";  // string type
   let rating_float = 4.5;                 // float type
   let is_growing_boolean = true;          // boolean type
   let icon_char = '♥';                    //unicode character type

   println!("company name is:{}",company_string);
   println!("company rating on 5 is:{}",rating_float);
   println!("company is growing :{}",is_growing_boolean);
   println!("company icon is:{}",icon_char);
}

Nell'esempio precedente, il tipo di dati delle variabili verrà dedotto dai valori loro assegnati. Ad esempio, Rust assegnerà il tipo di dati stringa alla variabile company_string , il tipo di dati float a rating_float , ecc.

Il println! macro richiede due argomenti:

• Una sintassi speciale {} , che è il segnaposto
• Il nome della variabile o una costante

Il segnaposto verrà sostituito dal valore della variabile

L'output dello snippet di codice sopra sarà:

company name is: TutorialsPoint
company rating on 5 is:4.5
company is growing: true
company icon is: ♥

Tipi scalari

Un tipo scalare rappresenta un singolo valore. Ad esempio, 10,3.14, "c". Rust ha quattro tipi di scalari primari.

• Integer
• Floating-point
• Booleans
• Characters

Impareremo a conoscere ogni tipo nelle nostre sezioni successive.

Numero intero

Un numero intero è un numero senza una componente frazionaria. In poche parole, il tipo di dati intero viene utilizzato per rappresentare i numeri interi.

I numeri interi possono essere ulteriormente classificati come con segno e senza segno. Gli interi con segno possono memorizzare valori sia negativi che positivi. Gli interi senza segno possono memorizzare solo valori positivi. Una descrizione dettagliata se i tipi interi è fornita di seguito:

Sr.No.	Taglia	Firmato	Non firmato
1	8 bit	i8	u8
2	16 bit	i16	u16
3	32 bit	i32	u32
4	64 bit	i64	u64
5	128 bit	i128	u128
6	Arco	isize	usize

La dimensione di un numero intero può essere arch . Ciò significa che la dimensione del tipo di dati sarà derivata dall'architettura della macchina. Un numero intero la cui dimensione è arch sarà di 32 bit su una macchina x86 e 64 bit su una macchina x64. Un intero arch viene utilizzato principalmente durante l'indicizzazione di una sorta di raccolta.

Illustrazione

fn main() {
   let result = 10;    // i32 by default
   let age:u32 = 20;
   let sum:i32 = 5-15;
   let mark:isize = 10;
   let count:usize = 30;
   println!("result value is {}",result);
   println!("sum is {} and age is {}",sum,age);
   println!("mark is {} and count is {}",mark,count);
}

L'output sarà come indicato di seguito:

result value is 10
sum is -10 and age is 20
mark is 10 and count is 30

Il codice precedente restituirà un errore di compilazione se si sostituisce il valore di età con un valore a virgola mobile.

Intervallo intero

Ogni variante con segno può memorizzare numeri da - (2 ^ (n-1) a 2 ^ (n-1) -1 , dove n è il numero di bit utilizzati dalla variante. Ad esempio, i8 può memorizzare numeri da - (2 ^ 7) a 2 ^ 7-1 - qui abbiamo sostituito n con 8.

Ogni variante senza segno può memorizzare numeri da 0 a (2 ^ n) -1 . Ad esempio, u8 può memorizzare numeri da 0 a 2 ^ 7 , che è uguale a 0 a 255.

Overflow di numeri interi

Un integer overflow si verifica quando il valore assegnato a una variabile intera supera l'intervallo definito da Rust per il tipo di dati. Facci capire questo con un esempio:

fn main() {
   let age:u8 = 255;

   // 0 to 255 only allowed for u8
   let weight:u8 = 256;   //overflow value is 0
   let height:u8 = 257;   //overflow value is 1
   let score:u8 = 258;    //overflow value is 2

   println!("age is {} ",age);
   println!("weight is {}",weight);
   println!("height is {}",height);
   println!("score is {}",score);
}

L'intervallo valido della variabile u8 senza segno è compreso tra 0 e 255. Nell'esempio precedente, alle variabili vengono assegnati valori maggiori di 255 (limite superiore per una variabile intera in Rust). All'esecuzione, il codice sopra restituirà un avviso:warning − literal out of range for u8per le variabili peso, altezza e punteggio. I valori di overflow dopo 255 inizieranno da 0, 1, 2, ecc. L'output finale senza preavviso è come mostrato di seguito -

age is 255
weight is 0
height is 1
score is 2

Galleggiante

Il tipo di dati Float in Rust può essere classificato come f32 e f64. Il tipo f32 è un float a precisione singola e f64 ha una precisione doppia. Il tipo predefinito è f64. Considera il seguente esempio per comprendere meglio il tipo di dati float.

fn main() {
   let result = 10.00;        //f64 by default
   let interest:f32 = 8.35;
   let cost:f64 = 15000.600;  //double precision
   
   println!("result value is {}",result);
   println!("interest is {}",interest);
   println!("cost is {}",cost);
}

L'output sarà come mostrato di seguito:

interest is 8.35
cost is 15000.6

Casting automatico del tipo

Il casting automatico del tipo non è consentito in Rust. Considera il seguente frammento di codice. Un valore intero viene assegnato alla variabile floatinterest.

fn main() {
   let interest:f32 = 8;   // integer assigned to float variable
   println!("interest is {}",interest);
}

Il compilatore lancia un file mismatched types error come indicato di seguito.

error[E0308]: mismatched types
   --> main.rs:2:22
   |
 2 | let interest:f32=8;
   |    ^ expected f32, found integral variable
   |
   = note: expected type `f32`
      found type `{integer}`
error: aborting due to previous error(s)

Separatore di numeri

Per una facile leggibilità di numeri grandi, possiamo utilizzare un separatore visivo _ trattino basso per separare le cifre. Cioè 50.000 può essere scritto come 50_000. Questo è mostrato nell'esempio seguente.

fn main() {
   let float_with_separator = 11_000.555_001;
   println!("float value {}",float_with_separator);
   
   let int_with_separator = 50_000;
   println!("int value {}",int_with_separator);
}

L'output è fornito di seguito:

float value 11000.555001
int value 50000

Booleano

I tipi booleani hanno due possibili valori: vero o falso . Utilizzare ilbool parola chiave per dichiarare una variabile booleana.

Illustrazione

fn main() {
   let isfun:bool = true;
   println!("Is Rust Programming Fun ? {}",isfun);
}

L'output del codice precedente sarà:

Is Rust Programming Fun ? true

Personaggio

Il tipo di dati carattere in Rust supporta numeri, alfabeti, Unicode e caratteri speciali. Utilizzare ilcharparola chiave per dichiarare una variabile del tipo di dati carattere. Il tipo char di Rust rappresenta un valore scalare Unicode, il che significa che può rappresentare molto di più del semplice ASCII. I valori scalari Unicode vanno daU+0000 per U+D7FF e U+E000 per U+10FFFF compreso.

Consideriamo un esempio per capire di più sul tipo di dati Character.

fn main() {
   let special_character = '@'; //default
   let alphabet:char = 'A';
   let emoji:char = '';
   
   println!("special character is {}",special_character);
   println!("alphabet is {}",alphabet);
   println!("emoji is {}",emoji);
}

L'output del codice precedente sarà:

special character is @
alphabet is A
emoji is