De generieke typen van Rust begrijpen

Er zijn altijd niveaus van onzekerheid tijdens het ontwikkelen van applicaties, wat kan leiden tot fouten, vooral als uw functies specifieke soorten argumenten accepteren. Om fouten als gevolg van onzekerheden te verminderen, kunt u Generics gebruiken. Generics bieden functionaliteit voor het maken van klassen, functies en gegevensstructuren voor het werken met verschillende typen.

Met behulp van generieke gegevens kunt u algoritmen en gegevensstructuren maken en definiëren die op meerdere typen kunnen werken zonder complexe code en afzonderlijke implementaties voor elk type te schrijven. Generics verbeteren de herbruikbaarheid en efficiëntie van code terwijl de veiligheid en prestaties van het type behouden blijven.

Generieke typen gebruiken in Rust

Het generieke type van Rust kan samenwerken met andere Rust-gegevenstypen. U definieert generieke typen met punthaken (<>), gevolgd door twee of meer parameters.

Hier is een generiek structuur definitie daarvoor zijn twee generieke typeparameters nodig:

structuurPunt {
// T en U zijn generieke typeparameters die de x- en y-velden gebruiken 
// neem aan bij instantiëring
 x: T,
 jij: jij,
}

In de Punt struct, T, En U zijn algemene typeparameters.

U kunt de parameters van het generieke type vervangen door elk gegevenstype bij instantiëring:

fnvoornaamst() {
laten mijn_punt = Punt { x: Snaar::van("Hallo"), j: Snaar::van("wereld") };
println!(
"De x-waarde van my_point is {} en de y-waarde is {}.",
 mijn_punt.x,
 mijn_punt.y
 );
}

De mijn punt variabele is een instantie van de Punt struct geïnitialiseerd met stringtypes. De Rust-compiler leidt de betonsoorten af ​​van T En U gebaseerd op de waarden bij instantiëring.

Eigenschapsgrenzen voor generieke typen

Rust-generieke typen kunnen eigenschapsgrenzen gebruiken om typeveiligheid te waarborgen. Traits zijn verzamelingen methoden die typen kunnen implementeren om bepaald gedrag te vertonen dat voor de eigenschap is gedefinieerd.

Eigenschapsgrenzen specificeren dat een generiek type een of meer eigenschappen moet implementeren.

Hier is een voorbeeld van een generieke functie die de grootste van twee waarden retourneert met een eigenschapsgrens die ervoor zorgt dat de vergeleken typen de eigenschap implementeren:

// Maximum is een eigenschap die een methode definieert voor het evalueren van het maximum van twee
// soorten
karaktereigenschapMaximaal {
fnmax(zelf, ander: Zelf) -> Zelf;
}
// Implementeert de eigenschap `Maximum` voor alle typen die de
// `PartialOrd` eigenschap.
implGedeeltelijke Ord> Maximaal voor T {
fnmax(zelf, ander: Zelf) -> Zelf {
// geef `self` terug als het groter is dan `other`; anders terugsturen
// `anders.`
alszelf > andere {
zelf
 } anders {
 ander
 }
 }
}
fnvoornaamst() {
laten een = 5;
laten b = 10;
laten grootste = Maximum:: max (a, b);
println!("De grootste waarde is {}", grootste);
}

De Maximaal eigenschap heeft een max methode die de grootste van twee waarden van hetzelfde type retourneert. Elk type dat de Gedeeltelijke Ord eigenschap implementeert de Maximaal karaktereigenschap.

De max methode neemt twee waarden van de Zelf type—verwijzend naar het type dat de Maximaal eigenschap - en vergelijkt de waarden.

De voornaamst functie vergelijkt twee variabelen met behulp van de max methode en drukt het grootste af.

Beperkingen voor generieke typen

Beperkingen zijn vergelijkbaar met kenmerkgrenzen, maar ze stellen u in staat aanvullende vereisten te specificeren voor typen die u als typeparameters gebruikt.

Als u een generieke functie wilt maken die typen voor tekenreeksconversie accepteert, kunt u een beperking gebruiken om ervoor te zorgen dat de parameter type een eigenschap implementeert.

// ToString is een eigenschap met een stringconversiemethode
karaktereigenschapToString {
fnnaar_tekenreeks(&zelf) -> Snaar;
}
// to_string is een generieke functie die een waarde aanneemt van elk type that
// implementeert de eigenschap ToString
fnnaar_tekenreeksToString>(waarde: T) -> Snaar {
 waarde.naar_string()
}

De naar_tekenreeks waardeparameter moet de ToString eigenschap, die ervoor zorgt dat u waarden van het type kunt converteren T rijgen met de naar_tekenreeks methode.

Generieke typen zijn handig voor het werken met eigenschappen

Rust-generieke typen zijn krachtig en er zijn verbeterpunten. Een cruciaal aandachtsgebied is het verbeteren van de prestaties van generieke code. Momenteel kan het typesysteem van Rust overhead opleggen aan generieke code, waardoor de prestaties worden vertraagd.

Generieke typen zijn gunstig voor het werken met eigenschappen. Door generieke typen te gebruiken, kunt u eigenschapobjecten maken die werken met elk type dat een eigenschap implementeert om uw methoden flexibeler te maken.