Pochopenie generických typov Rustu

Pri vývoji aplikácií vždy existujú úrovne neistoty, ktoré môžu viesť k chybám, najmä ak vaše funkcie akceptujú špecifické typy argumentov. Na zníženie chýb v dôsledku neistôt môžete použiť Generics. Generiká poskytujú funkcie na vytváranie tried, funkcií a dátových štruktúr na prácu s rôznymi typmi.

Pomocou generík môžete vytvárať a definovať algoritmy a dátové štruktúry, ktoré môžu fungovať na viacerých typoch bez písania zložitého kódu a samostatných implementácií pre každý typ. Generiká zlepšujú opätovnú použiteľnosť a efektivitu kódu pri zachovaní typovej bezpečnosti a výkonu.

Použitie generických typov v Rust

Rustov generický typ môže spolupracovať s iné typy údajov Rust. Všeobecné typy definujete pomocou lomených zátvoriek (<>), za ktorými nasledujú dva alebo viac parametrov.

Tu je generické definícia štruktúry ktorý má dva parametre všeobecného typu:

štrukturovaťBod {
// T a U sú parametre všeobecného typu, ktoré budú polia x a y 
// predpokladať inštanciáciu
 x: T,
 y: U,
}

V Bod štruktúra, T, a U sú parametre všeobecného typu.

Parametre všeobecného typu môžete nahradiť akýmkoľvek typom údajov pri vytváraní inštancie:

fnHlavná() {
nech my_point = Bod { x: Reťazec::od("Ahoj"), y: Reťazec::od("svet") };
println!(
"Hodnota x môjho_bodu je {} a hodnota y je {}.",
 my_point.x,
 my_point.y
 );
}

The my_point premenná je inštanciou premennej Bod struct inicializovaná s typmi reťazcov. Kompilátor Rust odvodzuje konkrétne typy T a U na základe hodnôt pri inštancii.

Hranice vlastností pre generické typy

Generické typy hrdze môžu používať hranice vlastností na zaistenie bezpečnosti typu. Vlastnosti sú kolekciou metód, ktoré typy môžu implementovať, aby vykazovali určité správanie definované pre danú vlastnosť.

Hranice vlastností určujú, že generický typ musí implementovať jednu alebo viacero vlastností.

Tu je príklad generickej funkcie, ktorá vracia väčšiu z dvoch hodnôt s väzbou vlastnosti, ktorá zaisťuje, že porovnávané typy implementujú vlastnosť:

// Maximum je vlastnosť, ktorá definuje metódu na vyhodnotenie maxima dvoch
// typy
vlastnosťMaximálne {
fnmax(seba, iné: Seba) -> Seba;
}
// Implementuje vlastnosť `Maximum` pre všetky typy, ktoré implementujú
// vlastnosť `PartialOrd`.
implČiastočná Obj> Maximum pre T {
fnmax(seba, iné: Seba) -> Seba {
// vráti "self", ak je väčšie ako "other"; v opačnom prípade sa vráťte
// "iné."
akseba > iné {
seba
 } inak {
 iné
 }
 }
}
fnHlavná() {
nech a = 5;
nech b = 10;
nech najväčší = Maximum:: max (a, b);
println!("Najväčšia hodnota je {}", najväčší);
}

The Maximálne vlastnosť má a max metóda, ktorá vráti väčšiu z dvoch hodnôt rovnakého typu. Akýkoľvek typ, ktorý implementuje Čiastočná Obj vlastnosť implementuje Maximálne vlastnosť.

The max metóda má dve hodnoty Seba typ—odvolávajúc sa na typ implementujúci Maximálne vlastnosť — a porovnáva hodnoty.

The Hlavná funkcia porovnáva dve premenné pomocou max spôsob a vytlačí najväčšiu.

Obmedzenia pre všeobecné typy

Obmedzenia sú podobné hraniciam vlastností, ale umožňujú vám zadať ďalšie požiadavky na typy, ktoré používate ako parametre typu.

Ak chcete vytvoriť generickú funkciu, ktorá akceptuje typy na konverziu reťazcov, môžete použiť obmedzenie, aby ste zabezpečili, že parameter typu implementuje vlastnosť.

// ToString je vlastnosť s metódou konverzie reťazca
vlastnosťNatiahnuť {
fnnatiahnuť(&seba) -> Reťazec;
}
// to_string je všeobecná funkcia, ktorá preberá hodnotu akéhokoľvek typu
// implementuje vlastnosť ToString
fnnatiahnuťNatiahnuť>(hodnota: T) -> Reťazec {
 value.to_string()
}

The natiahnuť parameter hodnota musí implementovať Natiahnuť vlastnosť, ktorá zaisťuje, že môžete konvertovať hodnoty typu T navliekať s natiahnuť metóda.

Všeobecné typy sú užitočné pri práci s vlastnosťami

Generické typy hrdze sú výkonné a existujú oblasti na zlepšenie. Kritická oblasť zamerania je zlepšenie výkonu generického kódu. V súčasnosti môže systém typu Rust zaťažiť generický kód a spomaliť výkon.

Generické typy sú prospešné pre prácu s vlastnosťami. Pomocou generických typov môžete vytvárať objekty vlastností, ktoré fungujú s akýmkoľvek typom implementujúcim vlastnosť, aby boli vaše metódy flexibilnejšie.