Array di stampa ruggine

Un array si riferisce a una raccolta di elementi di un tipo simile memorizzato in una posizione di memoria di connessione. Gli array sono fondamentali nella maggior parte dei linguaggi di programmazione in quanto forniscono una gestione dei dati correlati diversi ed efficienti.

In questo articolo, esploreremo come possiamo lavorare con array nel linguaggio di programmazione ruggine.

Rust Crea array

In Rust, creiamo un array usando una coppia di staffe quadrate nel formato come mostrato di seguito:

[T; N],

Dove t rappresenta il tipo di elementi da archiviare nell'array e n rappresenta la dimensione dell'array. Ricorda che la dimensione si riferisce al numero di elementi che un array può contenere.

Rust ci fornisce due metodi principali per la creazione di un array:

1. Un array con un elenco di elementi durante la dichiarazione.
2. Ripetere l'espressione in cui un elemento specificato viene ripetuto un numero specificato di elementi. La sintassi dell'array di ripetizione è come mostrato [n, x]. Questo crea una matrice di elementi x ripetuti n volte.

Rust dichiara e inizializza l'array

Esistono tre modi in cui possiamo dichiarare e inizializzare gli array in ruggine.

Ora, discutiamo:

Array senza tipo di dati o dimensioni

Il primo metodo per dichiarare un array è la creazione di un array senza un tipo di dati o una dimensione. Di seguito viene fornita una sintassi di esempio:

Siar = [1,2,3,4,5];

L'esempio precedente crea un array senza un tipo o una dimensione. Per ottenere la lunghezza dell'array, è possibile utilizzare la funzione Len () integrata.

fn main ()
Siar = [1,2,3,4,5];
println!("Lunghezza dell'array ", arr.len ());

L'esempio precedente dovrebbe restituire la lunghezza dell'array come:

Lunghezza dell'array 5

Array con tipo di dati e dimensioni

Il prossimo metodo per dichiarare un array è impostando il suo tipo e la dimensione. Una sintassi di esempio per dichiarare tale array è come mostrato di seguito:

ARR: [i32; 5] = [1,2,3,4,5];

La sintassi precedente crea un array di numeri interi firmati a 32 bit con una lunghezza di 5. Stampa la lunghezza dell'array dovrebbe restituire 5.

println!("Lunghezza dell'array ", arr.len ());
// 5

Array con valore predefinito

Puoi anche creare un array in cui tutti gli elementi di un elemento prendono un valore predefinito predefinito.

La sintassi è come mostrata:

let array_name: [array_type; array_size] = [default_value; array_size];

Un esempio è come mostrato:

ARR: [&str; 5] = ["a"; 5];

L'esempio precedente crea un array di type & STR con la dimensione di 5. Quindi, impostiamo un valore predefinito come "A" per tutti gli elementi nell'array.

Array di stampa ruggine

Per stampare un array in ruggine, utilizziamo l'operatore 😕 all'interno della stampa! funzione.

Un esempio è fornito di seguito:

fn main ()
ARR: [&str; 5] = ["a"; 5];
println!("Vettore :? ", arr);

Il codice precedente stampa gli elementi dell'array come previsto di seguito:

Array ["A", "A", "A", "A", "A"]

Rust Iterazione Array

Possiamo iterare sull'indice e gli elementi di un array usando un ciclo per loop o la funzione ITER. Ora, discutiamo.

Per l'iterazione del ciclo

Il metodo più comune per ripetere un array è usare un loop. Un codice di esempio è come mostrato di seguito:

fn main ()
ARR: [i32; 5] = [1,2,3,4,5];
per indice in 0 ... arr.len ()
println!("indice: , valore: ", indice, arr [indice]);

L'esempio precedente utilizza un ciclo per iterare l'indice dell'array dall'indice 0 alla lunghezza dell'array.

Ricorda che l'indicizzazione inizia all'indice 0 in ruggine.

Per accedere all'elemento memorizzato in un indice specifico, utilizziamo il nome dell'array e passiamo l'indice a cui desideriamo accedere all'interno di una coppia di staffe quadrate.

L'esecuzione del codice precedente dovrebbe restituire:

INDICE: 0, Valore: 1
INDICE: 1, Valore: 2
Indice: 2, valore: 3
Indice: 3, valore: 4
Indice: 4, valore: 5

Metodo ITER Rust

Possiamo anche usare il metodo ITER per gli elementi in un array. Un esempio è fornito di seguito:

fn main ()
ARR: [i32; 5] = [1,2,3,4,5];
per valore in arr.iter ()
println!("", valore);

Il codice precedente deve stampare ciascun elemento nell'array come mostrato di seguito:

1
--- troncato ---
5

Array mutabili

Per impostazione predefinita, gli array sono immutabili. Ciò significa che non puoi cambiare gli elementi una volta definiti. Per creare un array mutabile, è possibile aggiungere la parola chiave MUT durante la dichiarazione dell'array.

Un esempio è come mostrato:

Let MUT ARR: [i32; 5] = [1,2,3,4,5];

Dichiarare un array usando la sintassi precedente consente di modificare gli elementi nell'array.

Conclusione

In questo articolo, abbiamo esplorato come possiamo dichiarare e utilizzare array nel linguaggio di programmazione ruggine. Esistono tre modi per dichiarare e inizializzare gli array, che includono un array senza tipo di dati e dimensioni, un array con tipo di dati e dimensioni e un array con valore predefinito. Speriamo che tu abbia trovato questo articolo utile. Controlla gli altri articoli di suggerimento Linux per ulteriori suggerimenti e informazioni.