Bevezetés
A tuple könnyed módja annak, hogy egy rögzített, tetszőleges típusú adathalmazt együtt csoportosítsunk. A tuple-nek nincs külön neve; ha nevet adunk egy adatszerkezetnek, azzal struct-tá válik. A tuple mezőinek sincsenek nevei; a mezőkhoz destrukturálással vagy pozíció alapján férhetsz hozzá.
Szintaxis
Létrehozás
A tuple mindig tuple-kifejezéssel jön létre:
// pointless but legal
let unit = ();
// single element
let single_element = ("note the comma",);
// two element
let two_element = (123, "elements can be of differing types");
A tuple-oknak tetszőleges számú elemük lehet.
Elérés destrukturálással
A tuple elemeihez destrukturálással is hozzáférhetsz. Ez egyszerűen azt jelenti, hogy a tuple egyes elemeihez változóneveket rendelsz, és ezzel felhasználod a tuple-t.
let (elem1, _elem2) = two_element;
assert_eq!(elem1, 123);
Elérés pozíció alapján
A tuple elemeihez numerikus pozíció szerinti indexszel is hozzáférhetsz. Az indexelés, mint mindig, 0-tól kezdődik.
let notation = single_element.0;
assert_eq!(notation, "note the comma");
Tuple structok
Tuple structokkal is dolgoznod kell majd. A hagyományos structokhoz hasonlóan ezek is elnevezett típusok; a hagyományos structoktól eltérően viszont névtelen mezőik vannak. A szintaxisuk nagyon hasonlít a hagyományos tuple szintaxisához. A destrukturálás és a pozíció szerinti elérés egyaránt megengedett.
struct TupleStruct(u8, i32);
let my_tuple_struct = TupleStruct(123, -321);
let neg = my_tuple_struct.1;
let TupleStruct(byte, _) = my_tuple_struct;
assert_eq!(neg, -321);
assert_eq!(byte, 123);
A mezők láthatósága
A névtelen tuple-ok mezői mindig nyilvánosak. A tuple structok mezőinek viszont külön-külön van láthatóságuk, amely alapértelmezés szerint privát, akárcsak a hagyományos structok mezői esetében. A mezőket a pub módosítóval teheted nyilvánossá, csakúgy, mint egy hagyományos structban.
// fails due to private fields
mod tuple { pub struct TupleStruct(u8, i32); }
fn main() { let _my_tuple_struct = tuple::TupleStruct(123, -321); }
// succeeds: fields are public
mod tuple { pub struct TupleStruct(pub u8, pub i32); }
fn main() { let _my_tuple_struct = tuple::TupleStruct(123, -321); }
Utasítások
Egy alacsony fogyasztású beágyazott rendszerre szánt játékon dolgozol, és több kényelmi függvényt kell írnod, amelyeket a játék más részei fognak használni.
1. Számítsd ki egy osztás hányadosát és maradékát
A hányados egy osztás eredménye.
fn divmod(dividend: i16, divisor: i16) -> (i16, i16)
Példa:
assert_eq!(divmod(10, 3), (3, 1));
2. Válassz ki páros indexű elemeket egy iterátorból
A főnököd szerint ez majd segít egy képernyőpuffer-optimalizálást bevezetni.
Az iterátorok olyan elemek, amelyek az Iterator trait által definiált metódusokat teszik elérhetővé. Ez a dokumentáció meglehetősen terjedelmes, mert sok metódust kínálnak; íme a legfontosabb tulajdonságaik:
- Az iterátor egy tetszőleges hosszúságú elemfolyam
- Van egy
enumerate metódusuk, amely minden értékhez egy (i, val) tuple-t ad vissza
- Van egy
filter metódusuk, amely egy closure segítségével dönti el, hogy kiadjon-e egy elemet az iterátorból
- Van egy
map metódusuk, amely egy closure segítségével módosítja az iterátor elemeit
Mivel a függvényed bármilyen típusú iterátoron futhat, impl-t használ annak jelzésére, hogy ez egy trait-példány, nem pedig egy egyszerű elem. Hasonlóképpen a <Item=T> szintaxis csupán azt jelenti, hogy nem számít, milyen típusú elemet állít elő az iterátor; a függvényed bármely iterátor páros indexű elemeit elő tudja állítani.
fn evens<T>(iter: impl Iterator<Item=T>) -> impl Iterator<Item=T>
Példák:
let mut even_ints = evens(0_u8..);
assert_eq!(even_ints.next(), Some(0));
assert_eq!(even_ints.next(), Some(2));
assert_eq!(even_ints.next(), Some(4));
assert_eq!(even_ints.next(), Some(6));
let mut evens_from_odds = evens(1_i16..);
assert_eq!(evens_from_odds.next(), Some(1));
assert_eq!(evens_from_odds.next(), Some(3));
assert_eq!(evens_from_odds.next(), Some(5));
assert_eq!(evens_from_odds.next(), Some(7));
3. Számítsd ki egy pozíció manhattan-távolságát az origótól
A könnyebb leképezés érdekében kapsz egy Position tuple-structot:
struct Position(i16, i16);
Implementálnod kell egy manhattan metódust a Position típuson, amely visszaadja az adott pozíció manhattan-távolságát az origótól (Position(0, 0)).
impl Position {
fn manhattan(&self) -> i16
}
Példa:
assert_eq!(Position(3, 4).manhattan(), 7);
Tanulófeladat
