Разбиране на генеричните типове на Rust

Винаги има нива на несигурност при разработването на приложения, което може да доведе до грешки, особено ако вашите функции приемат специфични типове аргументи. За да намалите грешките, дължащи се на несигурност, можете да използвате Generics. Generics осигуряват функционалност за създаване на класове, функции и структури от данни за работа с различни типове.

С помощта на генерични продукти можете да създавате и дефинирате алгоритми и структури от данни, които могат да работят с множество типове, без да пишете сложен код и отделни реализации за всеки тип. Generics подобряват повторното използване на кода и ефективността, като същевременно поддържат безопасността на типа и производителността.

Използване на генерични типове в Rust

Общият тип на Rust може да взаимодейства с други типове данни на Rust. Ще дефинирате общи типове с ъглови скоби (<>), последвани от два или повече параметъра.

Ето един общ дефиниция на структура който приема два параметъра от общ тип:

структураТочка {
// T и U са параметри от общ тип, които полетата x и y ще направят 
// приемаме при инстанциране
 x: T,
 y: U,
}

В Точка структура, T, и U са параметри от общ тип.

Можете да замените параметрите на общия тип с произволен тип данни при инстанциране:

fnосновен() {
позволявам my_point = Точка { x: низ::от("Здравейте"), y: низ::от("свят") };
println!(
„Стойността x на my_point е {}, а стойността на y е {}.“,
 my_point.x,
 my_point.y
 );
}

The моята гледна точка променливата е екземпляр на Точка структура, инициализирана с типове низове. Компилаторът Rust извежда конкретните типове на T и U въз основа на стойностите при инстанциране.

Граници на характеристики за генерични типове

Общите типове на Rust могат да използват граници на признаци, за да осигурят безопасност на типа. Чертите са колекции от методи, които типовете могат да приложат, за да покажат определено поведение, дефинирано за чертата.

Границите на характеристиките указват, че генеричният тип трябва да реализира една или повече характеристики.

Ето пример за обща функция, която връща по-голямата от две стойности с обвързана характеристика, която гарантира, че сравняваните типове прилагат характеристиката:

// Максимумът е характеристика, която дефинира метод за оценка на максимума от две
// типове
Характерна чертаМаксимум {
fnмакс(себе си, друго: себе си) -> себе си;
}
// Внедрява характеристиката „Максимум“ за всички типове, които прилагат
// черта `PartialOrd`.
имплPartialOrd> Максимум за T {
fnмакс(себе си, друго: себе си) -> себе си {
// връща `self`, ако е по-голямо от `other`; в противен случай се върнете
// `друго.`
акосебе си > други {
себе си
 } друго {
 друго
 }
 }
}
fnосновен() {
позволявам а = 5;
позволявам b = 10;
позволявам най-големият = Максимум:: макс (a, b);
println!(„Най-голямата стойност е {}“, най-големият);
}

The Максимум черта има a макс метод, който връща по-голямата от две стойности от един и същи тип. Всеки тип, който прилага PartialOrd черта прилага Максимум Характерна черта.

The макс методът приема две стойности на себе си тип—позовавайки се на типа, изпълняващ Максимум черта—и сравнява стойностите.

The основен функцията сравнява две променливи с помощта на макс метод и отпечатва най-големия.

Ограничения за генерични типове

Ограниченията са подобни на границите на характеристиките, но ви позволяват да укажете допълнителни изисквания за типовете, които използвате като параметри на типа.

Ако искате да създадете генерична функция, която приема типове за преобразуване на низове, можете да използвате ограничение, за да гарантирате, че параметърът тип изпълнява характеристика.

// ToString е характеристика с метод за преобразуване на низ
Характерна чертаToString {
fnкъм_низ(&себе си) -> низ;
}
// to_string е обща функция, която приема стойност от всеки тип, който
// имплементира характеристиката ToString
fnкъм_низToString>(стойност: T) -> низ {
 value.to_string()
}

The към_низ стойностният параметър трябва да изпълнява ToString черта, която гарантира, че можете да конвертирате стойности от тип T да низ с към_низ метод.

Общите типове са полезни за работа с черти

Общите типове Rust са мощни и има области за подобрение. Критична област на фокус е подобряването на производителността на общия код. Понастоящем типовата система на Rust може да наложи допълнителни разходи върху общия код, забавяйки производителността.

Генеричните типове са полезни за работа с черти. Използвайки генерични типове, можете да създавате обекти на характеристики, които работят с всеки тип, имплементиращ черта, за да направите вашите методи по-гъвкави.