Come lavorare con la proprietà in ruggine

In questo articolo, esploreremo la proprietà di Rust e come funziona. L'approccio della proprietà e del prestito è un costrutto relativamente nuovo e inciampano nuovi mobili. In questa guida, tenteremo di demistificare come funziona la proprietà.

Cos'è la proprietà?

Tradizionalmente, ci sono due modi fondamentali per gestire i ricordi. Il primo sono i collezionisti di immondizia; È usato principalmente in linguaggi di alto livello che astraggono il concetto di gestione della memoria dal programmatore.

Il secondo è la gestione della memoria "manuale", in cui il programmatore definisce esplicitamente l'utilizzo della memoria. Sebbene fornisca il controllo, lascia molto spazio per sparare ai piedi.

Rust adotta un approccio alternativo chiamato proprietà e prestito. La proprietà è un nuovo "costrutto" che definisce un valore ha il suo proprietario.

Le seguenti sono le regole di proprietà in ruggine:

1. Qualsiasi valore definito in un programma Rust ha un proprietario.
2. Un valore può avere un proprietario alla volta.
3. Un valore può vivere solo fintanto che il suo proprietario è vivo. Significa che il proprietario non è stato abbandonato.

Per comprendere meglio la proprietà della ruggine, discutiamo di alcuni concetti ed esempi.

Scopo

Possiamo definire l'ambito come un intervallo in base al quale vive un valore specificato. L'ambito svolge un ruolo importante nella proprietà e in prestito.

Ogni variabile è vincolata dal suo ambito. In questo caso, un ambito si riferisce a un blocco come racchiuso da una coppia di bretelle.

Considera il seguente programma di esempio:

fn main ()
// definito nell'ambito della funzione principale
let long_life = 100;

// definito in un blocco interno (nuovo ambito)
let short_life = 10;
println!("Ambito interno: ", short_life);

// short_life non esiste in questo ambito
println!("Ambito esterno: ", short_life);
println!("Long Life: ", long_life);

fn new_func ()
println!("Scopi di funzione: ", long_life);

Nel programma di esempio precedente, abbiamo due funzioni: la funzione principale e la funzione new_func.

All'interno della funzione principale, dichiariamo una nuova variabile chiamata Long_Life. Creiamo anche un nuovo ambito e dichiariamo una nuova variabile chiamata short_life.

Se si esegue il codice precedente, il compilatore Rust ti dirà che le variabili, Short_Life e Long_Life, non esistono in quell'ambito.

Questo perché la variabile short_life è dichiarata in un nuovo ambito. Quando questo ambito termina, la variabile viene eliminata. Ciò significa che la variabile corta_life non esiste al di fuori delle parentesi cure.

Lo stesso caso si applica alla variabile Long_Life. È accessibile solo nella funzione principale. Non è consentito tentare di accedervi in ​​un'altra funzione.

Ombra

L'ombra variabile è un caso tipico. Si riferisce a una funzione in cui la prima dichiarazione variabile viene "sovrascritta" o ombreggiata da un'altra.

Prendi il seguente codice di esempio:

fn main ()
Sia var1 = 10;
println!("Prima dell'ombra: ", var1);
// dopo l'ombra
Let var1 = 100;
println!("After Shadow: ", var1);

Qui, abbiamo una variabile chiamata VAR1 impostata su 10. Quindi, lo ombriamo dichiarando la variabile con lo stesso nome e la imposta su un nuovo valore.

Questo dovrebbe stampare:

Nota: non confondere l'ombra con mutabilità. Controlla il nostro tutorial sulla mutabilità della ruggine per saperne di più.

Trasferisci la proprietà

Rust ci consente di trasferire la proprietà del valore utilizzando le operazioni di copia o spostamento. Prendi il seguente codice di esempio:

fn main ()
Sia var1 = 10;
let var2 = var1;
println!("var1: ", var1);
println!("var2: ", var2);

L'esempio precedente dichiara una variabile, var1, e gli assegna il valore 10. Dichiariamo anche una nuova variabile, var2, e la assegniamo a var1.

Quando ciò accade, Rust creerà una nuova copia del valore e lo assegnerà a var2. Ciò significa che entrambe le variabili non condividono il valore e ognuna occupa il proprio spazio di memoria.

Cosa succede quando tentiamo di eseguire l'operazione precedente su un valore con una dimensione della memoria non deterministica?

Prendi un tipo di stringa, ad esempio. Dal momento che può crescere o ridursi, non esiste una dimensione della memoria predeterminata. Quindi, non implementa il tratto di copia:

let str1 = string :: da ("ciao");
Lascia che str2 = str1;
println!("str1: ", str1);
println!("str1: ", str2);

L'esecuzione delle stesse operazioni costringe il compilatore Rust a spostare il valore di STR1 su STR2. Poiché un valore può avere un solo proprietario alla volta, la variabile STR1 non è più valida. Ciò farà restituire un errore il compilatore se tentiamo di accedervi:

Conclusione

Uno dei motivi per cui i Rustacei adorano il linguaggio di programmazione Rust è la proprietà. È una nuova funzionalità che offre più flessibilità e sicurezza allo stesso tempo. Comprendere come funziona può essere utile per la creazione di applicazioni rapide ed efficienti. Inoltre, sono state discusse le regole di proprietà e concetti. Speriamo che tu abbia trovato questo articolo utile. Controlla gli altri articoli di suggerimento Linux per ulteriori suggerimenti e informazioni.