tytuł oryginału: programming rust: fast, safe systems … · 2021. 2. 11. · 4 spis treści...

Tytuł oryginału: Programming Rust: Fast, Safe Systems Development

Tłumaczenie: Adam Bochenek (wstęp, rozdz. 1 – 20), Krzysztof Sawka (rozdz. 21)

ISBN: 978-83-283-5740-2

© 2019 Helion S.A.

Authorized Polish translation of the English edition of Programming Rust ISBN 9781491927281© 2018 Jim Blandy and Jason Orendorff

This translation is published and sold by permission of O’Reilly Media, Inc., which owns or controls all rights to publish and sell the same.

All rights reserved. No part of this book may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording or by any information storage retrieval system, without permission from the Publisher.

Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną, fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje naruszenie praw autorskich niniejszej publikacji.

Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich właścicieli.

Autor oraz Helion SA dołożyli wszelkich starań, by zawarte w tej książce informacje były kompletnei rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz Helion SA nie ponoszą równieżżadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce.

Helion SAul. Kościuszki 1c, 44-100 Gliwicetel. 32 231 22 19, 32 230 98 63e-mail: [email protected]: http://helion.pl (księgarnia internetowa, katalog książek)

Drogi Czytelniku!Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/prrustMożesz tam wpisać swoje uwagi, spostrzeżenia, recenzję.

Pliki z przykładami omawianymi w książce można znaleźć pod adresem: ftp://ftp.helion.pl/przyklady/prrust.zip

Printed in Poland.

• Kup książkę• Poleć książkę • Oceń książkę

• Księgarnia internetowa• Lubię to! » Nasza społeczność

http://helion.pl/rt/prrust

http://helion.pl/rf/prrust

http://helion.pl/ro/prrust

http://helion.pl

http://ebookpoint.pl/r/4CAKF

3

Spis treści

Wstęp ....................................................................................................................... 15

1. Dlaczego Rust? .......................................................................................................... 19Bezpieczeństwo typów 21

2. Pierwsze spotkanie z Rustem ..................................................................................... 25Pobranie i instalacja Rusta 25Prosta funkcja 28Pisanie i uruchamianie testów 29Obsługa argumentów wiersza poleceń 30Prosty serwer web 34Programowanie współbieżne 41

Czym jest zbiór Mandelbrota? 42Parsowanie argumentów wiersza poleceń 46Odwzorowanie pikseli na liczby zespolone 48Rysowanie zbioru 50Zapis obrazu do pliku 51Program Mandelbrota działający współbieżnie 53Uruchomienie programu 57Przezroczyste bezpieczeństwo 57

3. Typy proste ............................................................................................................... 59Typy maszynowe 62

Typy całkowite 62Typy zmiennoprzecinkowe 65Typ logiczny 67Typ znakowy 67

Poleć książkęKup książkę



4 Spis treści

Krotki 69Typy wskaźnikowe 71

Referencje 71Pudełka 72Wskaźniki niechronione 72

Tablice, wektory i podzbiory 72Tablice 73Wektory 74Dodawanie pojedynczych elementów do wektora 77Podzbiory 77

Typ String 79Literały łańcuchowe 79Łańcuchy bajtów 80Łańcuchy znaków w pamięci 80Typ String 82Podstawowe cechy typu String 83Inne typy znakowe 83

Co dalej? 84

4. Reguła własności ...................................................................................................... 85Reguła własności 87Przeniesienie własności 91

Więcej operacji związanych z przeniesieniem własności 96Przeniesienie własności a przepływ sterowania 97Przeniesienie własności a struktury indeksowane 98

Typy kopiowalne 100Rc i Arc: własność współdzielona 103

5. Referencje .............................................................................................................. 107Referencje jako wartości 111

Referencje Rusta kontra referencje C++ 111Referencje a operacja przypisania 112Referencje do referencji 112Porównywanie referencji 113Referencje nigdy nie są puste 114Referencje do wyrażeń 114Referencje do podzbiorów i zestawów metod 115

Bezpieczeństwo referencji 115Referencja do zmiennej lokalnej 115Parametry w postaci referencji 118Referencje jako argumenty 120




Spis treści 5

Referencja jako wartość zwracana 121Struktura zawierająca referencje 122Odrębny cykl życia 124Pomijanie parametrów cyklu życia 125

Referencje współdzielone kontra mutowalne 127Walka ze sztormem na morzu obiektów 134

6. Wyrażenia ...............................................................................................................137Język wyrażeń 137Bloki kodu i średniki 138Deklaracje 140if i match 141

if let 143Pętle 144Wyrażenie return 146Analiza przepływu sterowania 146Wywołania funkcji i metod 148Pola i elementy 149Operatory referencji 150Operatory arytmetyczne, bitowe, porównania i logiczne 150Przypisanie 151Rzutowanie typów 152Domknięcia 153Priorytety operatorów 153Co dalej? 156

7. Obsługa błędów .......................................................................................................157Błąd panic 157

Odwinięcie stosu 158Przerywanie procesu 159

Typ Result 160Przechwytywanie błędów 160Alias typu Result 161Wyświetlanie informacji o błędach 162Propagacja błędów 163Jednoczesna obsługa błędów różnych typów 164Błędy, które nie powinny się zdarzyć 166Ignorowanie błędów 167Obsługa błędów w funkcji main() 167Definiowanie własnego typu błędu 168Co daje nam typ Result? 169




6 Spis treści

8. Paczki i moduły ....................................................................................................... 171Paczki 171

Profile budowania 174Moduły 174

Umieszczanie modułów w oddzielnych plikach 175Ścieżki i importy 177Standardowe preludium 179Podstawowe składniki modułów 179

Zmiana programu w bibliotekę 181Katalog src/bin 183Atrybuty 184Testy i dokumentacja 186

Testy integracyjne 188Dokumentacja 189Doc-testy 191

Definiowanie zależności 193Wersje 194Cargo.lock 195

Publikowanie paczek na stronie crates.io 196Obszary robocze 198Więcej fajnych rzeczy 199

9. Struktury ................................................................................................................ 201Struktury z polami nazywanymi 201Struktury z polami numerowanymi 204Struktury puste 204Reprezentacja struktur w pamięci 205Definiowanie metod w bloku impl 206Struktury generyczne 209Struktury z parametrem cyklu życia 210Dziedziczenie standardowych zestawów metod 211Zmienność wewnętrzna 212

10. Typy wyliczeniowe i wzorce ..................................................................................... 217Typy wyliczeniowe 218

Typy wyliczeniowe zawierające dane 220Typ wyliczeniowy w pamięci 221Większe struktury danych stosujące typy wyliczeniowe 222Generyczne typy wyliczeniowe 223




Spis treści 7

Wzorce 226Literały, zmienne i symbole wieloznaczne 228Wzorce w postaci krotki lub struktury 230Wzorce z referencjami 231Dopasowanie do wielu wartości 233Warunki dodatkowe 234Wzorce @ 235Gdzie używamy wzorców 235Wypełnianie drzewa binarnego 236

Podsumowanie 238

11. Zestawy metod (interfejsy) i typy generyczne ...........................................................239Stosowanie zestawów metod 241

Obiekt implementujący zestaw metod 242Struktura obiektu implementującego 243Funkcje generyczne 244Na co się zdecydować? 247

Definiowanie i implementacja zestawów metod 249Metody domyślne 250Implementacja zestawów metod dla istniejących już typów 251Zestaw metod a słowo kluczowe Self 252Rozszerzanie zestawu metod (dziedziczenie) 254Metody statyczne 254

W pełni kwalifikowana nazwa metody 255Zestawy metod definiujące relacje między typami 257

Typy powiązane 257Generyczny zestaw metod (czyli jak działa przeciążanie operatorów) 260Zaprzyjaźnione zestawy metod (czyli jak działa generator liczb pseudolosowych) 261

Inżynieria wsteczna ograniczeń 263Wnioski 266

12. Przeciążanie operatorów ..........................................................................................267Operatory arytmetyczne i bitowe 268

Operatory jednoargumentowe 270Operatory dwuargumentowe 271Operatory przypisania złożonego 272

Test równości 273Porównania szeregujące 276Interfejsy Index i IndexMut 278Inne operatory 281




8 Spis treści

13. Interfejsy narzędziowe ............................................................................................ 283Drop 284Sized 287Clone 289Copy 290Deref i DerefMut 291Default 294AsRef i AsMut 296Borrow i BorrowMut 297From i Into 299ToOwned 301Borrow i ToOwned w działaniu 302

14. Domknięcia ............................................................................................................. 305Przechwytywanie zmiennych 306

Domknięcia, które pożyczają wartość 307Domknięcia, które przejmują własność 308

Typy funkcji i domknięć 309Domknięcia a wydajność 311Domknięcia a bezpieczeństwo 313

Domknięcia, które zabijają 313FnOnce 314FnMut 315

Funkcje zwrotne 317Skuteczne korzystanie z domknięć 320

15. Iteratory ................................................................................................................. 323Iterator i IntoIterator 324Tworzenie iteratorów 326

Metody iter i iter_mut 326Implementacje interfejsu IntoIterator 326Metoda drain 328Inne źródła iteratorów 329

Adaptery 330map i filter 330filter_map i flat_map 333scan 335take i take_while 335skip i skip_while 336peekable 337fuse 338




Spis treści 9

Iteratory obustronne i rev 339inspect 340chain 341enumerate 341zip 342by_ref 342cloned 344cycle 344

Konsumowanie iteratorów 345Proste agregaty: count, sum i product 345max i min 345max_by i min_by 346max_by_key i min_by_key 346Porównywanie sekwencji elementów 347any i all 348position, rposition oraz ExactSizeIterator 348fold 349nth 349last 350find 350Tworzenie kolekcji: collect i FromIterator 350Zestaw metod Extend 352partition 353

Implementacja własnych iteratorów 354

16. Kolekcje ...................................................................................................................359Przegląd kolekcji 360Vec<T> 361

Dostęp do elementów 362Iteracja 363Zwiększanie i zmniejszanie wielkości wektora 364Łączenie 367Podział 367Zamiana 369Sortowanie i wyszukiwanie 370Porównywanie podzbiorów 371Elementy losowe 372Reguły zapobiegające konfliktom w czasie iteracji 372

VecDeque<T> 373LinkedList<T> 375




10 Spis treści

BinaryHeap<T> 376HashMap<K, V> i BTreeMap<K, V> 377

Entry 380Iterowanie map 381

HashSet<T> i BTreeSet<T> 382Iteracja zbioru 383Kiedy równe wartości są różne 383Operacje dotyczące całego zbioru 383

Haszowanie 385Niestandardowe algorytmy haszujące 386

Kolekcje standardowe i co dalej? 387

17. Tekst i łańcuchy znaków .......................................................................................... 389Podstawy Unicode 389

ASCII, Latin-1 i Unicode 390UTF-8 390Kierunek tekstu 392

Znaki (typ char) 392Klasyfikacja znaków 392Obsługa cyfr 393Zmiana wielkości liter 394Konwersja znaku do i z liczby całkowitej 394

Typy String i str 395Tworzenie łańcuchów znaków 396Prosta inspekcja 396Dołączanie i wstawianie tekstu 397Usuwanie tekstu 398Konwencje nazewnicze dotyczące wyszukiwania i iterowania 399Wyszukiwanie tekstu i wzorce 399Wyszukiwanie i zamiana 400Iterowanie tekstu 401Obcinanie 403Zmiana wielkości liter w łańcuchach 403Konwersja tekstu do wartości innego typu 404Konwersja wartości innego typu do tekstu 404Tworzenie referencji innego typu 405Tekst jako UTF-8 406Tworzenie tekstu na podstawie danych UTF-8 406Alokacja warunkowa 407Łańcuchy znaków jako kolekcje generyczne 409




Spis treści 11

Formatowanie wartości 410Formatowanie tekstu 411Formatowanie liczb 412Formatowanie innych typów 414Formatowanie wartości z myślą o debugowaniu 415Formatowanie i debugowanie wskaźników 416Wiązanie argumentów za pomocą indeksu i nazwy 416Dynamiczne definiowanie długości i precyzji 417Formatowanie własnych typów 417Użycie języka formatowania we własnym kodzie 419

Wyrażenia regularne 421Podstawowe użycie wyrażeń regularnych 421Wyrażenia regularne w trybie leniwym 422

Normalizacja 423Rodzaje normalizacji 424Biblioteka unicode-normalization 425

18. Operacje wejścia/wyjścia ..........................................................................................427Obiekty typu reader i writer 428

Obiekty typu reader 429Buforowany obiekt typu reader 431Przeglądanie tekstu 432Pobieranie tekstu 434Obiekty typu writer 435Pliki 436Wyszukiwanie 437Inne rodzaje obiektów reader i writer 437Dane binarne, kompresja i serializacja 439

Pliki i katalogi 440OsStr i Path 440Metody typów Path i PathBuf 442Funkcje dostępu do systemu plików 443Odczyt zawartości katalogu 444Funkcje bezpośrednio związane z platformą 446

Obsługa sieci 447

19. Programowanie współbieżne ...................................................................................451Podział i łączenie wątków 453

spawn i join 454Obsługa błędów w różnych wątkach 456Współdzielenie niemutowalnych danych przez różne wątki 457




12 Spis treści

Rayon 459Zbiór Mandelbrota raz jeszcze 461

Kanały 463Wysyłanie wartości 464Odczyt wartości 467Uruchomienie potoku 468Cechy kanałów i ich wydajność 470Bezpieczeństwo wątków: Send i Sync 472Współpraca iteratora i kanału 474Potoki i co dalej? 475

Stan współdzielony mutowalny 476Czym jest muteks? 476Mutex<T> 478mut i Mutex 480Dlaczego Mutex to nie zawsze dobry pomysł? 480Zakleszczenie (deadlock) 481Zatruty muteks 482Kanały z wieloma nadawcami stosujące muteksy 482Blokady odczytu/zapisu (RwLock<T>) 483Zmienne warunkowe (Condvar) 485Typy atomowe 485Zmienne globalne 487

Rust i pisanie programów wielowątkowych 489

20. Makra ..................................................................................................................... 491Podstawy 492

Rozwijanie makra 493Niezamierzone skutki 495Powtórzenia 496

Makra wbudowane 498Debugowanie makr 499Makro json! 500

Typy składników 501Makra a rekurencja 504Makra i zestawy metod 505Zakres i higiena 507Import i eksport makr 509

Unikanie błędów składniowych w procesie dopasowywania 511macro_rules! i co dalej? 512




Spis treści 13

21. Kod niebezpieczny ...................................................................................................513Dlaczego niebezpieczny? 514Bloki unsafe 515

Przykład: skuteczny typ łańcucha znaków ASCII 516Funkcje unsafe 518Kod niebezpieczny czy funkcja niebezpieczna? 520Niezdefiniowane zachowanie 521Zestawy metod unsafe 523Wskaźniki niechronione 525

Bezpieczne tworzenie dereferencji wskaźników niechronionych 528Przykład: RefWithFlag 529Wskaźniki dopuszczające wartość pustą 531Rozmiary i rozmieszczanie typów 531Operacje arytmetyczne na wskaźnikach 532Wchodzenie do pamięci i wychodzenie z pamięci 534Przykład: GapBuffer 537Bezpieczeństwo błędów paniki w kodzie niebezpiecznym 543

Funkcje obce: wywoływanie kodu C i C++ w środowisku Rusta 544Wyszukiwanie wspólnych reprezentacji danych 544Deklarowanie obcych funkcji i zmiennych 547Korzystanie z funkcji i bibliotek 549Interfejs niechroniony dla biblioteki libgit2 552Interfejs bezpieczny dla biblioteki libgit2 558

Podsumowanie 568

Skorowidz ................................................................................................................569




14 Spis treści




19

ROZDZIAŁ 1.

Dlaczego Rust?

W pewnych warunkach — ale z myślą o takich właśnie warunkach powstał Rust — bycie dziesięć razy,a nawet dwa razy szybszym od konkurencji jest kwestią być albo nie być. Kwestią decydującą

o losie systemu na rynku oprogramowania. Na rynku sprzętu komputerowego zresztą też.

— Graydon Hoare (http://graydon.livejournal.com/236436.html)

Wszystkie komputery przetwarzają obecnie równolegle…Programować współbieżnie to znaczy programować.

— Michael McCool i współautorzy, Structured Parallel Programming

Błąd parsera TrueType pozwolił na włamanie do systemu i inwigilację; żyjemy w czasach, w których kwestie bezpieczeństwa dotykają absolutnie całego oprogramowania.

— Andy Wingo (https://twitter.com/andywingo/status/610765099498872832)

Języki programowania systemowego mają za sobą długą drogę. Od 50 lat używamy języków wy-sokiego poziomu do pisania systemów operacyjnych. I przez cały ten czas mamy dwa problemy,których nie umiemy do końca rozwiązać:

Trudno jest stworzyć w pełni bezpieczny kod. Szczególnie trudne jest prawidłowe zarządza-nie pamięcią w C i C++. Użytkownicy od dziesięcioleci cierpią z powodu konsekwencji tychbłędów. A spektakularne luki w bezpieczeństwie systemów znane są co najmniej od roku 1988,kiedy pojawił się robak Morrisa (ang. Morris worm).

Tworzenie wielowątkowego kodu jest bardzo skomplikowane. A jedynie kod wielowątkowyjest w stanie w pełni wykorzystać możliwości współczesnego sprzętu. Nawet bardzo doświad-czeni programiści podchodzą do tego zagadnienia z respektem. Współbieżność generuje no-we typy potencjalnych problemów i błędów, które na dodatek znacznie trudniej jest zlokali-zować i naprawić.

Dlatego zachęcamy do poznania Rusta: bezpiecznego, współbieżnego języka programowaniao wydajności porównywalnej z C i C++.

Rust to nowy język programowania systemowego opracowany przez Mozillę i związaną z niąspołeczność. Podobnie jak C i C++, Rust zapewnia programistom ścisłą kontrolę nad wykorzy-staniem pamięci i utrzymuje bliski związek między typami używanymi w programie a ich repre-zentacją po stronie maszyny, na której program działa. Pomaga to programistom ocenić koszty




20 Rozdział 1. Dlaczego Rust?

działania programu. Rust spełnia postulaty zawarte w artykule Bjarna Stroustrupa zatytułowanymAbstraction and the C++ Machine Model:

Generalnie implementacje C++ stosują się do zasady zerowego narzutu: jeśli czegoś nie używamy,to za to nie płacimy. A idąc dalej: tego, co zawarte jest w kodzie, nie da się zrealizować lepiej.

Do dwóch powyższych obietnic Rust dodaje jeszcze dwie własne: bezpieczne zarządzanie pamię-cią i poprawnie działająca współbieżność.

Kluczem do spełnienia wszystkich tych obietnic jest nowatorska reguła własności, zasada przenie-sienia własności oraz obsługa referencji. Poprawne użycie tych reguł sprawdzane jest już na etapiekompilacji kodu i stanowi trudne do przecenienia uzupełnienie dla elastycznego systemu typówjęzyka Rust. Reguła własności zapewnia przejrzysty i łatwy do kontrolowania czas życia każdejwartości, dzięki czemu zbędne staje się wprowadzanie na poziomie języka mechanizmu odśmie-cania pamięci. Elastyczne i bezpieczne staje się zarządzanie innymi rodzajami zasobów, takimi jakpliki czy gniazda sieciowe. Reguła przeniesienia własności jasno określa, w jaki sposób własnośćobiektu transferowana jest z jednej zmiennej do innej, referencje zaś pozwalają na dostęp dowartości obiektów bez posiadania prawa własności. Ponieważ wielu programistów mogło niespotkać się ze wspomnianymi przed chwilą pojęciami nigdy wcześniej, zagadnieniom tym po-święcimy w całości rozdziały 4. i 5.

Te same reguły własności stanowią również podstawę niezawodnego modelu programowaniawspółbieżnego w języku Rust. W większości języków nie istnieje związek pomiędzy obiektamisłużącymi do synchronizacji wątków (muteks) a danymi, do których dostęp jest za pomocą tychobiektów chroniony. Jest to realizowane wyłącznie na podstawie umowy i komentarzy w kodzie.Rust już na poziomie kompilacji sprawdza, czy muteks faktycznie chroni przed nieprawidłowymdostępem do danych. W przypadku większości języków zaleca się, żeby nie korzystać w programiegłównym ze struktury danych, którą zaczęliśmy przetwarzać w osobnym wątku. Rust po prostu nato nie pozwoli. Rust już na poziomie kompilacji zapobiega sytuacjom, w których może dojść dowyścigu o dane.

Rust nie jest językiem w pełni obiektowym, choć wiele cech języka obiektowego posiada. Nie jest teżjęzykiem funkcyjnym, choć wpływ języków funkcyjnych na pewne zastosowane w nim rozwiąza-nia są widoczne, szczególnie w obszarze sposobu zwracania wyników. Rust bazuje na C i C++, alema tyle nowatorskich rozwiązań, że kod napisany w tym języku nie przypomina kodu w C czy C++.Wydaje się, że najlepiej wstrzymać się z porównaniami i ostateczną ocenę wystawić dopiero w mo-mencie, gdy opanuje się ten język w stopniu pozwalającym na swobodne w nim programowanie.

Najlepszym sprawdzianem dla nowych pomysłów jest zastosowanie ich w świecie rzeczywistym.Dlatego też najnowszy silnik przeglądarki internetowej, o nazwie Servo, Mozilla zdecydowała sięzaimplementować właśnie w języku Rust. Okazało się bowiem, że cele postawione przed Rustemi potrzeby Servo bardzo dobrze do siebie pasują. Przeglądarka musi działać szybko i niezawodnieoraz bezpiecznie obsługiwać niezaufane dane. Servo wykorzystuje bezpieczną współbieżność Rusta,w oddzielnych wątkach realizuje nawet to, co w C++ zrównoleglić byłoby naprawdę trudno. Taknaprawdę Rust i Servo dorastały razem. Servo korzystało z nowych rozwiązań dodawanych do ję-zyka, a Rust ewoluował w oparciu o opinie wyrażane przez programistów Servo.




Bezpieczeństwo typów 21

Bezpieczeństwo typówRust jest językiem bezpiecznie typowanym. Co to znaczy? Samo pojęcie bezpieczeństwa brzmidobrze, ale na czym ono ma w tym przypadku polegać?

Oto definicja działania nieokreślonego zaczerpnięta z normy języka C w specyfikacji 1999, znanejjako C99:

Działanie nieokreślone

Działanie w przypadku użycia nieprzenośnej lub błędnej konstrukcji programu lub błędnychdanych, dla których niniejszy standard nie nakłada żadnych wymagań

Przeanalizujmy działanie następującego programu napisanego w języku C:

int main(int argc, char **argv) { unsigned long a[1]; a[3] = 0x7ffff7b36cebUL; return 0;}

Zgodnie ze specyfikacją C99, ponieważ program sięga do elementu tablicy, który znajduje się po-za jej zakresem (indeks 3 elementu wykracza poza dopuszczalny zakres tablicy a), zachowanieprogramu jest nieokreślone. Oznacza to, że może wydarzyć się cokolwiek. Kiedy uruchomiliśmyprogram na laptopie Jima, efekt był następujący:

undef: Error: .netrc file is readable by others.undef: Remove password or make file unreadable by others.

Program wyświetlił komunikat i zakończył się z błędem. Co ciekawe, na laptopie Jima nie byłopliku o nazwie .netrc. Jeśli wykonasz podobny eksperyment u siebie, wydarzy się najprawdopo-dobniej zupełnie coś innego.

Kod maszynowy funkcji main wygenerowany przez kompilator C umieszcza na stosie tablicę a, poniej znajduje się adres powrotny funkcji. Tak więc wpisanie wartości 0x7ffff7b36cebUL do ele-mentu a[3], który nie istnieje, bo jest już poza tablicą, zmienia wartość adresu powrotnego. Adres tenwskazuje teraz na kod ze środka biblioteki standardowej C. Trafiliśmy akurat na fragment, któryprzegląda plik .netrc w poszukiwaniu hasła. Zakładany powrót z funkcji main zamienia się na wy-wołanie kodu maszynowego odpowiadającego następującym wierszom biblioteki standardowej:

warnx(_("Error: .netrc file is readable by others."));warnx(_("Remove password or make file unreadable by others.")); goto bad;

Dopuszczenie do sytuacji, w której odwołanie się do elementu tablicy ma wpływ na zmianę adresupowrotu funkcji, jest, jak widać, w pełni zgodne ze standardami języka C. Operacja o nieokreślonymdziałaniu po prostu niesie ze sobą nieokreślony wynik. Program może zrobić dosłownie cokolwiek.

Standard C99 daje kompilatorowi (i programiście) carte blanche. Celem jest umożliwienie do-wolnej optymalizacji zmierzającej do uzyskania szybszego kodu. Zamiast kompilatora odpowie-dzialnego za wykrywanie i obsługę niepożądanych zachowań (takich jak na przykład wychodzeniepoza zakres tablicy), standard zakłada, że programista jest odpowiedzialny za zapewnienie, aby takienieprawidłowe sytuacje nigdy nie miały miejsca.





Niestety doświadczenie pokazuje, że w pisaniu kodu o odpowiedniej jakości nie jesteśmy dobrzy.Będąc studentem na Uniwersytecie w Utah, Peng Li zmodyfikował używane tam kompilatory Ci C++ w taki sposób, by raportowały wykryte w czasie kompilacji potencjalne źródła nieokreślo-nego zachowania kompilowanych przez siebie programów. Odkrył, że tego typu niedoskonałościwystępują bardzo często i że dotyczy to również projektów, które mają status bardzo ważnychi w związku z tym spełniają ponoć wysokie standardy kodowania. Działanie nieokreślone częstoprowadzi do wykorzystywania luk i wprowadzania niebezpiecznego kodu. Robak Morrisa roz-przestrzeniał się z jednej maszyny na drugą właśnie przy użyciu rozwinięcia pokazanej przez nastechniki. Także dziś wiele wirusów działa właśnie w ten sposób.

Przy okazji tego przykładu zdefiniujmy pewne pojęcia. Jeśli program został napisany w ten sposób,że żadne jego użycie nie jest w stanie doprowadzić do sytuacji, którą moglibyśmy nazwać działa-nie nieokreślonym, możemy powiedzieć, że program jest dobrze zdefiniowany. Jeśli mechanizmykontroli samego języka programowania są w stanie zapewnić, że każdy program jest dobrze zde-finiowany, język taki uznać możemy za bezpieczny.

Starannie napisany program C lub C++ może być bezpieczny, ale sam język tego nie gwarantuje.C i C++ nie mają systemu typów, który zapewnia poprawność działającego programu. Przykładpokazany przez nas kompiluje się bez błędów, choć później działa nieprzewidywalnie. Bezpiecznypod tym względem jest natomiast Python. Program napisany w tym języku poświęca czas proce-sora na wykrywanie i obsługę indeksów, które wykraczają poza dopuszczalny zakres. Dzieje się tow sposób znacznie bardziej przyjazny niż w C:

>>> a = [0]>>> a[3] = 0x7ffff7b36cebTraceback (most recent call last): File "<stdin>", line 1, in <module>IndexError: list assignment index out of range>>>

Program napisany w Pythonie w analogicznej sytuacji zgłosił wyjątek. A to nie jest już działanienieokreślone. Specyfikacja języka Python jasno precyzuje, że przypisanie do a[3] zakończy sięzwróceniem wyjątku typu IndexError. Oczywiście istnieją sposoby, by i za pomocą Pythona do-prowadzić do nietypowych sytuacji, ale trzeba w tym celu skorzystać z dodatkowych modułów,takich jak na przykład ctypes. Sam język jest natomiast pod tym względem bezpieczny. Podobniejak Java, JavaScript, Ruby czy Haskell.

Zwróć uwagę, że bezpieczeństwo na poziomie systemu typów nie zależy od tego, czy sprawdzeniedokonywane jest na poziomie kompilacji czy w czasie działania programu (czyli od tego, czy ję-zyk jest typowany statycznie czy dynamicznie). C sprawdza typy podczas kompilacji i bezpiecznynie jest. Python robi to w czasie działania i bezpieczeństwo zapewnia.

Ironią jest, że dominujące języki programowania systemowego, czyli C i C++, nie zapewniająbezpieczeństwa na poziomie typów, podczas gdy większość języków aplikacyjnych cechę taką po-siada. Biorąc pod uwagę, że C i C++ używane są do implementacji fundamentów systemu, któ-rym powierzono odpowiedzialność za bezpieczeństwo systemu i kontakt z zewnętrznymi danymi,którym nie można ufać, omawiana przez nas cecha bezpieczeństwa na poziomie samego językapowinna być priorytetem.




Bezpieczeństwo typów 23

Jest to bolączka, która trapi nas od kilku dekad i Rust próbuje być na to lekarstwem. Jest to wy-dajny język programowania systemowego zapewniający równocześnie bezpieczeństwo na poziomiesystemu typów. Rust jest przeznaczony do implementacji podstawowych warstw systemowych,które wymagają najwyższej wydajności i drobiazgowej kontroli nad zasobami, ale nadal gwaran-tuje poziom przewidywalności zapewniany przez bezpieczeństwo typów. W niniejszej książce na-piszemy, jak Rust radzi sobie z pogodzeniem tych sprzecznych na pierwszy rzut oka postulatów.

Ten szczególny rodzaj bezpieczeństwa, który oferuje nam Rust, ma zaskakujące konsekwencje dlaprogramowania wielowątkowego. Programowanie współbieżne zawsze było trudne w C i C++.Dlatego programiści sięgali do tych technik niechętnie, zwykle wtedy, gdy kod jednowątkowyokazywał się niezdolny do osiągnięcia wymaganej wydajności. Rust gwarantuje już na poziomiejęzyka, że współbieżny kod jest wolny od wyścigu do danych, wychwytując nieprawidłowe użyciemuteksów lub innych obiektów synchronizacji na etapie kompilacji. W języku Rust możesz uży-wać współbieżności, nie martwiąc się o to, że popełnisz błąd lub że Twój kod będzie niezrozu-miały dla innych.

A co w sytuacji, gdy nie mamy wyjścia i musimy bezwzględnie skorzystać z bezpośredniego, „suro-wego” wskaźnika, biorąc całą odpowiedzialność za działanie tego fragmentu programu na siebie?Istnieje taka furtka, możemy w Ruście pisać tzw. niebezpieczny kod, o czym więcej piszemy w roz-dziale 21. Na szczęście większość programów nie będzie z tych mechanizmów korzystać.

Elastyczny system typów języka Rust nie służy tylko i wyłącznie zapewnieniu bezpieczeństwai uchronieniu nas przed wystąpieniem niepożądanych sytuacji. Doświadczony programista używaodpowiednich typów w sposób pozwalający dobrze i zwięźle oddać jego intencje. Sprzyjają temuszczególnie zestawy metod (ang. traits) oraz typy generyczne, którym poświęcamy rozdział 11. To zaich pomocą możemy zwięźle i elastycznie wyrazić zestaw wspólnych cech grupy typów i późniejefektywnie te cechy wykorzystywać.

Celem naszej książki jest przekazanie Ci wiedzy i doświadczeń potrzebnych do pisania progra-mów w języku Rust w sposób poprawny, to znaczy taki, aby były wydajne, bezpieczne oraz przej-rzyste. Z naszego doświadczenia wynika, że Rust jest ważnym krokiem naprzód w programowaniusystemowym, i chcemy Cię za pomocą niniejszej książki do tego przekonać.




569

Skorowidz

Aadapter, 330

chain, 341cloned, 344cycle, 344enumerate, 341filter, 331filter_map, 333flat_map., 333fuse, 338inspect, 340map, 330peekable, 337rev, 340scan, 335skip, 336skip_while, 336take, 335take_while, 335zip, 342

algorytmy haszujące, 386alias typu Result, 161aliasy typów, 180all, 348alokacja warunkowa, 407any, 348architektura Flux, 321ASCII, 80, 390, 516AsMut, 296AsRef, 296atomowe operacje, 452atrybuty, 184

Bbezpieczeństwo, 57, 313

błędów paniki, 543referencji, 115

typów, 21wątków, 472

biblioteka, 181libgit2, 552, 558Rayon, 459unicode-normalization, 425

BinaryHeap<T>, 361, 376blokady

odczytu/zapisu, 483typu muteks, 477

blokiextern, 181kodu, 138unsafe, 515

błąd panic, 157błędy, 157

ignorowanie, 167jednoczesna obsługa, 164paniki, 543propagacja, 163przechwytywanie, 160różnych typów, 164składniowe, 511typ Result, 160, 169w funkcji main, 167własny typ, 168wyświetlanie informacji, 162

Borrow, 297, 302BorrowMut, 297BTreeMap<K, V>, 361, 377BTreeSet<T>, 361, 382bufor odstępu, 537by_ref, 342

CCargo.lock, 195chain, 341Clone, 289

cloned, 344collect, 350Condvar, 485Copy, 290count, 345cycle, 344cyfry, 393

Ddane binarne, 439deadlock, 481debugowanie, 415

makr, 499wskaźników, 416

Default, 294definiowanie

metod, 206zależności, 193zestawów metod, 249

deklaracje, 140obcych funkcji, 547obcych zmiennych, 547składników lokalnych, 140

Deref, 291dereferencja wskaźników

niechronionych, 528DerefMut, 291doc-testy, 191dokumentacja, 186, 189dołączanie tekstu, 397domknięcia, 153, 305

bezpieczeństwo, 313Fn, 316FnMut, 316FnOnce, 316pożyczające wartość, 307przejmujące własność, 308typy, 309wydajność, 311




570 Skorowidz

dopasowanie do wielu wartości, 233drain, 328Drop, 284drzewa binarne, 236dwukropek, 177dynamiczne definiowanie

długości, 417precyzji, 417

dziedziczenie, 254metod, 211

Eelementy, 149Entry, 380enumerate, 341ExactSizeIterator, 348Extend, 352

Ffilter, 330filter_map, 333find, 350flat_map, 333Flux, 321FnMut, 315FnOnce, 314fold, 349formatowanie

liczb, 412tekstu, 411wartości, 410, 415własnych typów, 417wskaźników, 416

From, 299funkcja, 28, 148, 179

copy_to, 446main(), 167spawn, 454

funkcjedostępu do systemu plików, 443generyczne, 60, 244niebezpieczne, 520obce, 544powiązane, 206unsafe, 518zwrotne, 317

fuse, 338

GGapBuffer, 537generator liczb pseudolosowych,

261generyczne

funkcje, 244typy wyliczeniowe, 223

generyczny zestaw metod, 260gruby wskaźnik, 77

HHashMap<K, V>, 361, 377HashSet<T>, 361, 382haszowanie, 385

Iignorowanie błędów, 167implementacja

interfejsu Drop, 284interfejsu IntoIterator, 326własnych iteratorów, 354zestawów metod, 249, 251

importy, 177, 181indeks odwrócony, 464, 474informacje

o błędach, 162o łańcuchu znaków, 396

inspect, 340instalacja, 25interfejs, 239

AsMut, 296AsRef<T>, 296Copy, 291Default, 294Drop, 284Extend, 352FnOnce, 314FromIterator, 351Index, 278IndexMut, 278IntoIterator, 326, 324

interfejsybezpieczne, 558funkcji obcych, 544narzędziowe, 283niechronione, 552

Into, 299IntoIterator, 324, 326inżynieria wsteczna ograniczeń, 263iter, 326iter_mut, 326iteracja, 372

zbioru, 383iterator, 323, 399

ExactSizeIterator, 348Iterator, 324iteratory

konsumowanie, 345obustronne, 339tworzenie, 326własne, 354źródła, 329

iterowaniemap, 381tekstu, 401

Jjęzyk wyrażeń, 137join, 454

Kkacze typowanie, 60kanał synchroniczny, 471kanały, 463

cechy, 470muteksy, 482wydajność, 470

katalog src/bin, 183katalogi, 440kierunek tekstu, 392klasyfikacja znaków, 392klonowanie wartości, 290kod niebezpieczny, 513, 520kolejka dwustronna, 360, 373kolekcja, 359

BinaryHeap<T>, 361, 376BTreeMap<K, V>, 361, 377BTreeSet<T>, 361, 382HashMap<K, V>, 361, 377HashSet<T>, 361, 382LinkedList<T>, 360, 375Vec<T>, 360, 361VecDeque<T>, 360, 373




Skorowidz 571

kolekcjeniestandardowe, 387tworzenie, 350

kompresja, 439kontrakt, 514konwersja

tekstu, 404wartości, 404znaku, 394

kopiec binarny, 361, 376krotki, 69, 230

Llast, 350Latin-1, 390len, 348liczby zespolone, 48LinkedList<T>, 360, 375lista wiązana, 360, 375literały, 228

łańcuchowe, 79

Łłańcuch

bajtów, 80znaków, 80, 389, 396, 516znaków jako kolekcje

generyczne, 409łączenie wątków, 453

Mmakra, 491

a rekurencja, 504debugowanie, 499eksport, 509higieniczne, 507import, 509niezamierzone skutki, 495powtórzenia, 496proceduralne, 512rozwijanie, 493typy składników, 503wbudowane, 498zakres, 507zestawy metod, 505

makroformat!(), 82format_args!, 419json!, 500

map, 330mapa

iterowanie, 381typ Entry, 380uporządkowana, 361, 377z haszowaniem, 361, 377

max, 345max_by, 346max_by_key, 346metoda, 148, 180

.join(), 456all, 348any, 348by_ref, 343clone, 289collect, 350concat(), 82count, 345default, 294drain, 328find, 350fold, 349iter, 326iter_mut, 326join(separator), 82last, 350len, 348max, 345max_by_key, 346min, 345min_by, 346min_by_key, 346nth, 349partition, 353position, 348product, 345rposition, 348sum, 345to_string(), 82

metody, Patrz także: zestaw metodkwalifikowana nazwa, 255domyślne, 250interfejsu PartialOrd, 277statyczne, 208, 254w bloku impl, 206

min, 345min_by, 346min_by_key, 346moduły, 174, 181

składniki, 179morze obiektów, 134

zsynchronizowanych, 452mut, 480muteks, 476

zatruty, 482Mutex, 480Mutex<T>, 478

Ntyp [T, 72nazwa metody, 255niezdefiniowane zachowanie, 521normalizacja, 423nth, 349

Oobcinanie tekstu, 403obiekt

buforowany typu reader, 431implementujący zestaw

metod, 242, 243obiekty

typu reader, 428, 429typu writer, 428, 435

obsługabłędów, 157, 456błędów w funkcji main(), 167cyfr, 393jednoczesna błędów, 164sieci, 447

obszary robocze, 198odczyt

wartości, 467zawartości katalogu, 444

odstęp, 537odwinięcie stosu, 158operacja przypisania, 112operacje

arytmetyczne na wskaźnikach,532

wejścia/wyjścia, 427operator ::, 177




572 Skorowidz

operatory, 281arytmetyczne, 150, 268bitowe, 150, 268dwuargumentowe, 271jednoargumentowe, 270logiczne, 150porównania, 150, 277priorytety, 153przeciążanie, 260, 267przypisania złożonego, 272referencji, 150

OsStr, 440

Ppaczki, 171

publikowanie, 196pamięć, 534parametr cyklu życia, 119, 210parametry, 118

cyklu życia, 125parsowanie argumentów, 46partition, 353Path, 440, 442PathBuf, 442peekable, 337pętla, 144

for, 144loop, 144while, 144while let, 144

plik README.md, 199pliki, 436, 440

zapisywanie danych, 51z modułami, 175

pobieranie tekstu, 434podzbiory, 77podział wątków, 453pola, 149

nazywane, 201numerowane, 204

polimorfizm, 239porównania szeregujące, 276porównywanie sekwencji

elementów, 347position, 348potoki, 468, 452

adapterów iteratora, 474wątków, 474

priorytety operatorów, 153product, 345programowanie współbieżne, 41,

451propagacja błędów, 163przechwytywanie

błędów, 160zmiennych, 306

przeciążanie operatorów, 260, 267przeglądanie tekstu, 432przeniesienie własności, 91

operacje, 96przepływ sterowania, 97struktury indeksowane, 98

przepływ sterowania, 97, 146przerywanie procesu, 159przymus dereferencji, 292przypisanie, 151publikowanie paczek, 196pudełka, 72pule wątków, 452

RRayon, 459referencja &Self, 292referencje, 71, 107, 150, 287

bezpieczeństwo, 115C++, 111do podzbiorów, 115do referencji, 112do wyrażeń, 114do zestawów metod, 115do zmiennej lokalnej, 115innego typu, 405jako argumenty, 120jako wartości, 111, 121mutowalne, 109, 127odrębny cykl życia, 124operacja przypisania, 112parametry, 118porównywanie, 113puste, 114rusta, 111w strukturze, 122współdzielone, 109, 127, 133

RefWithFlag, 529reguła własności, 85, 87

rekurencja, 504relacja

częściowej równoważności, 275równoważności, 275

relacje między typami, 257rev, 340rodzaje normalizacji, 424rozmiary typów, 531równoległość danych, 452rposition, 348Rust, 19RwLock<T>, 483rysowanie zbioru, 50rzutowanie typów, 152

Sscan, 335serializacja, 439serwer web, 34sieć, 447sized type, 287skip, 336skip_while, 336składniki modułów, 179skrypt kompilacji, 551słowo kluczowe Self, 252spawn, 454stałe, 180stan współdzielony mutowalny, 476str, 395String, 395struktura, 201, 230

literałuzmiennoprzecinkowego, 65

zawierająca referencje, 122struktury

generyczne, 209indeksowane, 98puste, 204reprezentacja w pamięci, 205stosujące typy wyliczeniowe,

222z parametrem cyklu życia, 210z polami nazywanymi, 201z polami numerowanymi, 204

sum, 345surowy łańcuch znaków, 79




Skorowidz 573

symbol$x, 497?Sized, 288<T>, 209

symbole wieloznaczne, 233

Śścieżki, 177średniki, 138

Ttablice, 72, 73take, 335take_while, 335tekst, 389

UTF-8, 406testy, 29, 186

integracyjne, 188równości, 273

ToOwned, 301tworzenie

iteratorów, 326kolekcji, 350łańcuchów znaków, 396referencji, 405tekstu, 406

typ, 179&[T], 72&mut [T], 72char, 392logiczny, 67łańcuchowy OsStr, 441o stałym rozmiarze, 287o zmiennym rozmiarze, 287Path, 442PathBuf, 442Result, 160, 169str, 395String, 79, 82, 83, 395Vec<T>, 72wyliczeniowy w pamięci, 221znakowy, 67

typyatomowe, 485całkowite, 62domknięć, 309funkcji, 309

generyczne, 239iterowalne, 325języka C, 545kopiowalne, 100maszynowe, 62powiązane, 257proste, 59rozmiary, 531rozmieszczanie, 531wskaźnikowe, 71wyliczeniowe, 218

generyczne, 223zawierające dane, 220

zmiennoprzecinkowe, 65znakowe, 83

UUnicode, 80, 389, 390unsafe, 515, 518unsized type, 287uruchamianie

potoku, 468programu, 57testu, 29

usuwanie tekstu, 398UTF-8, 80, 390użycie

funkcji, 549wyrażeń regularnych, 421

VVec<T>, 360, 361VecDeque<T>, 360, 373

Wwątki

bezpieczeństwo, 472działające w tle, 452łączenie, 453obsługa błędów, 456podział, 453współdzielenie

niemutowalnych danych, 457wektor, 360, 361

dostęp do elementów, 362elementy losowe, 372

iteracja, 363, 372łączenie, 367podział, 367porównywanie podzbiorów,

371sortowanie, 370wyszukiwanie, 370zamiana elementów, 369zmniejszanie wielkości, 364zwiększanie wielkości, 364

wektory, 74wersje, 194wiązanie argumentów, 416wiersz poleceń, 30własność współdzielona, 103wskaźniki

const w C++, 133dopuszczające wartość pustą,

531niechronione, 72, 525operacje arytmetyczne, 532słabe, 105

współbieżność, 41, 451wstawianie tekstu, 397wydajność, 311, 470wyłączny dostęp, 480wyrażenia, 137

regularne, 421regularne w trybie leniwym, 422

wyrażenieif, 141if let, 143match, 142return, 146

wysyłanie wartości, 464wyszukiwanie, 437

tekstu, 399wywołania funkcji i metod, 148wzorce, 226, 228, 399

@, 235krotki, 230nieodrzucalne, 236odrzucalne, 236struktury, 230z referencjami, 231

wzorzec Model-View-Controller,320




574 Skorowidz

Zzakleszczenie, 481zależności, 193zapis do pliku, 51zaprzyjaźnione zestawy metod, 261zarządzanie pamięcią, 534zbiory

iteracja, 383operacje, 383równe wartości, 383

zbiórMandelbrota, 42, 53, 461uporządkowany, 382z haszowaniem, 361, 382

zestaw metod, 239Borrow, 297BorrowMut, 297definiowanie, 249

DerefMut, 291DoubleEndedIterator, 339Extend, 352From, 299generyczny, 260implementacja, 249, 251Into, 299Iterator, 324obiekt implementujący, 242przeciążanie operatorów, 268relacje między typami, 257rozszerzanie, 254Send, 472słowo kluczowe Self, 252std::marker::Sync, 472stosowanie, 241struktura obiektu

implementującego, 243

ToOwned, 301unsafe, 523zaprzyjaźniony, 261

zip, 342zmiana wielkości liter, 394, 403zmienne, 228

globalne, 487lokalne, 115warunkowe, 485zainicjalizowane, 536

zmienność wewnętrzna, 212znacznik, 221znaki, 392

Źźródła iteratorów, 329




http://program-partnerski.helion.pl

tytuł oryginału: programming rust: fast, safe systems … · 2021. 2. 11. · 4 spis treści...

Documents