Rust : développez des programmes robustes et sécurisés

Auteur(s) :

Prieur, Benoît (1975-....) Découvrir l'auteur

Résumé

Destiné aux développeurs, l'ouvrage présente les concepts fondamentaux du langage, notamment la gestion de la mémoire impliquant les tas et la pile ainsi que celles relatives au multithreading. Les notions centrales en Rust que sont la propriété et l'emprunt font également l'objet de larges développements. Des compléments sont disponibles en ligne.

Éditeur(s)
- 1ditions ENI
Date
- C 2022
Notes
- La couv. porte en plus : "Informatique technique" ; "+ quiz" ; "Version en ligne offerte ! pendant 1 an"
- La 4e de couv. indique : "Sur www.editions-eni.fr : le code source des exemples du livre"
- Contient un "flashcode" permettant d'acéder à un contenu via Internet
Langues
- Français
Description matérielle
- 1 vol. (362 p.) : ill. ; 21 cm
Collections
- Expert IT
ISBN
- 978-2-409-03528-9
Indice
- 681.25 Autres langages informatiques
Quatrième de couverture
- Rust
  Développez des programmes robustes et sécurisés
  Ce livre sur le langage Rust s'adresse en premier lieu aux développeurs connaisseurs du C/C++, voire de langages comme Python ou C#, désireux d'apprendre ce langage adapté à la programmation système sécurisée.
  Les premiers chapitres permettent de rendre accessible le propos, non seulement à un public issu du monde C++, mais également à un public connaisseur du développement logiciel via un langage plus éloigné. Ainsi, les concepts fondamentaux du langage sont étudiés, notamment la gestion de la mémoire impliquant le tas (heap) et la pile (stack). Les notions centrales en Rust que sont la propriété et l'emprunt font également l'objet de larges développements. La gestion de la mémoire est également abordée du point de vue de l'usage du multithreading.
  Puis, au fil de la lecture, vous explorez également les notions de modules et de caisses (crates), de structures, d'énumérations et de filtrage par motif ainsi que les traits, les closures et les principales collections utilisées en Rust. Un chapitre est également consacré à la notion de WebAssembly, ainsi qu'un autre aux notions avancées en Rust.
  Des éléments complémentaires sont en téléchargement sur le site www.editions-eni.fr.
Tables des matières
- - Rust
  - Développez des programmes robustes et sécurisés
  - Éditions Eni
  - Avant-propos
  - Chapitre 1
  - Comment et pourquoi Rust ?
  - 1. Introduction13
  - 2. Contexte d'invention et nature du langage Rust14
  - 3. Pourquoi le langage Rust ?15
  - 3.1 La question de la gestion de la mémoire15
  - 3.1.1 La pile15
  - 3.1.2 Le tas16
  - 3.1.3 Le typage sûr16
  - 3.2 La question de la gestion concurrentielle des threads19
  - 3.2.1 Contexte d'utilisation du parallélisme19
  - 3.2.2 Situation de compétition20
  - 3.2.3 L'enfer de l'exclusion mutuelle22
  - 4. Conclusion24
  - Chapitre 2
  - Commençons à utiliser concrètement Rust
  - 1. Installation et exploration25
  - 1.1 L'outil rustup25
  - 1.2 L'outil central : cargo28
  - 1.2.1 Versions installées28
  - 1.2.2 Un premier projet28
  - 1.2.3 Analyse et explications relatives au premier projet29
  - 1.2.4 Commandes principales cargo31
  - 2. Premiers travaux en Rust33
  - 2.1 Un premier exemple de programme Rust33
  - 2.2 Exécution du programme36
  - 2.3 Compléments apportés au programme37
  - 3. Outils complémentaires autour du projet réalisé39
  - 3.1 Un mot sur les tests unitaires en Rust39
  - 3.2 Un mot sur l'organisation par module42
  - 3.3 Un mot sur la ligne de commande45
  - 4. Nommons les choses - Un peu de vocabulaire47
  - 4.1 Introduction47
  - 4.2 Petit lexique du langage Rust47
  - 4.2.1 Mutabilité47
  - 4.2.2 Structure (struct)47
  - 4.2.3 Trait et générique47
  - 4.2.4 Caisse (crate) et module48
  - 4.2.5 Propriété et emprunt48
  - 5. Conclusion49
  - Chapitre 3
  - Types, structures de données en Rust
  - 1. Introduction51
  - 2. Les types primitifs simples52
  - 2.1 Types numériques entiers52
  - 2.1.1 Entiers signés52
  - 2.1.2 Entiers non signés52
  - 2.1.3 Entiers codés d'après la taille du processeur53
  - 2.2 Types numériques flottants53
  - 2.3 Le type booléen54
  - 2.4 Le type char54
  - 3. Les types primitifs, structures de données54
  - 3.1 Le tuple54
  - 3.2 La structure struct56
  - 3.2.1 Structure, cas général56
  - 3.2.2 Structure et mutabilité58
  - 3.2.3 Le tuple structure59
  - 4. Les types pointeurs en Rust60
  - 4.1 Références en Rust60
  - 4.2 Boîte (box) en Rust64
  - 4.3 Pointeurs bruts (raw pointers) en Rust66
  - 5. Les types tableaux, vecteurs et tranches69
  - 5.1 Introduction69
  - 5.2 Les tableaux en Rust69
  - 5.3 Les vecteurs en Rust71
  - 5.4 Les tranches en Rust75
  - 6. Le type chaîne de caractères (string)78
  - 6.1 Introduction78
  - 6.2 Cas pratique autour de string79
  - 7. Conclusion81
  - Chapitre 4
  - Possession et emprunt en Rust
  - 1. Introduction83
  - 1.1 Le tas et la pile84
  - 1.2 Utilité de la possession84
  - 2. Fonctionnement de la possession85
  - 2.1 Grands principes85
  - 2.2 Exemples relatifs à la propriété85
  - 2.2.1 Propriété dans le tas86
  - 2.2.2 Propriété dans la pile88
  - 2.3 Plus loin avec la propriété : usage avec fonctions91
  - 2.3.1 Passage de valeur à une fonction91
  - 2.3.2 Retour de fonction92
  - 2.4 Conclusion à propos de la possession93
  - 3. Fonctionnement de l'emprunt93
  - 3.1 Introduction93
  - 3.2 Exemple : transfert de propriété vs emprunt94
  - 3.2.1 Transfert de propriété94
  - 3.2.2 Emprunt95
  - 3.3 Emprunt à base de références mutables98
  - 4. Conclusion99
  - Chapitre 5
  - Structures en Rust
  - 1. Premières structures en Rust101
  - 1.1 Introduction101
  - 1.2 Structure à champs nommés102
  - 1.2.1 Syntaxe102
  - 1.2.2 La question de la visibilité103
  - 1.3 Structure - tuple107
  - 1.4 Structure - unité109
  - 1.5 Un mot de l'implantation mémoire d'une structure109
  - 2. Les méthodes de structure en Rust110
  - 2.1 Prototype des méthodes110
  - 2.2 Usage du mot-clé self111
  - 2.3 Un exemple d'utilisation des méthodes111
  - 2.4 Vers les méthodes statiques en Rust113
  - 3. Structure générique115
  - 3.1 Introduction115
  - 3.2 Exemple support115
  - 3.3 Exemple support augmenté117
  - 4. La question des références dans une structure120
  - 4.1 Introduction120
  - 4.2 Mise en évidence du besoin d'annotation de durée de vie ... .121
  - 4.3 Durée de vie basée sur le mot-clé static122
  - 5. Notion de traits appliqués aux structures124
  - 5.1 Introduction124
  - 5.2 Les traits prédéfinis appliqués aux structures124
  - 6. Conclusion126
  - Chapitre 6
  - Énumérations et motifs en Rust
  - 1. Introduction127
  - 2. Les énumérations en Rust128
  - 2.1 Premiers exemples128
  - 2.2 Exemple de conversion d'entiers vers une énumération131
  - 2.2.1 Les options dans la librairie standard131
  - 2.2.2 Premiers filtrages par motif132
  - 2.3 Un mot sur les méthodes d'énumération135
  - 2.4 Utiliser des structures dans des énumérations137
  - 2.4.1 Introduction137
  - 2.4.2 Exemple d'utilisation137
  - 2.5 Les énumérations génériques139
  - 2.5.1 Exemple dans la librairie standard139
  - 2.5.2 Arbre binaire avec une énumération générique140
  - 3. Filtrage par motif142
  - 3.1 Premier exemple, pour rappel142
  - 3.2 Plus loin avec les motifs144
  - Chapitre 7
  - Les traits en Rust
  - 1. Introduction149
  - 2. Premier trait en Rust150
  - 2.1 Création d'une caisse et d'un exécutable client150
  - 2.2 Définition d'un trait153
  - 3. Utiliser un trait en paramètre160
  - 3.1 Introduction160
  - 3.2 Exemple de trait en paramètre160
  - 3.3 Plusieurs paramètres d'un même trait en paramètre162
  - 4. Notion de trait lié163
  - 4.1 Introduction163
  - 4.2 Plusieurs traits liés différents pour un même paramètre163
  - 4.2.1 Introduction163
  - 4.2.2 Le trait prédéfini Display163
  - 4.2.3 Création de la structure Tortue164
  - 4.2.4 Un mot sur la clause where166
  - 5. Un trait comme valeur de retour167
  - 5.1 Introduction167
  - 5.2 Exemple support167
  - 6. Points d'architecture impliquant les traits169
  - 6.1 Traits, génériques et structures169
  - 6.2 Un mot sur les sous-traits171
  - Chapitre 8
  - Les traits prédéfinis en Rust
  - 1. Introduction173
  - 2. Des traits prédéfinis essentiels : les itérateurs173
  - 3. Notion de surcharge d'opérateurs176
  - 3.1 Introduction176
  - 3.2 Les opérateurs surchargeables177
  - 3.3 Exemple support178
  - 3.3.1 Contexte des nombres complexes178
  - 3.3.2 Premiers éléments de programmation178
  - 3.3.3 Surcharges des opérateurs + et -179
  - 3.3.4 Surcharges de la comparaison181
  - 4. Inventaire et usage de quelques traits prédéfinis182
  - 4.1 L'usage de Derive182
  - 4.1.1 Explications182
  - 4.1.2 Exemple support183
  - 4.2 Inventaire des traits185
  - 4.2.1 Introduction185
  - 4.2.2 Le trait Drop186
  - 4.2.3 Les traits Deref et DerefMut187
  - 4.2.4 Le trait Default188
  - 4.2.5 Le trait From189
  - Chapitre 9
  - Les chaînes de caractères en Rust
  - 1. Introduction193
  - 2. Encodages Unicode et UTF-8 et caractères en Rust194
  - 2.1 Quelques définitions194
  - 2.2 Encodage en Rust194
  - 2.2.1 Le type char et l'Unicode194
  - 2.2.2 Les types String et str et l'UTF-8194
  - 3. À la découverte des caractères (char) en Rust195
  - 3.1 Nature des caractères195
  - 3.2 Casse des caractères197
  - 3.3 Conversion vers un entier197
  - 4. À la découverte de String et str199
  - 4.1 Introduction199
  - 4.2 Le type str199
  - 4.3 Le type String201
  - 4.3.1 Construction du type201
  - 4.3.2 Création d'un String201
  - 4.3.3 Premiers outils autour de String204
  - 4.3.4 Insertion dans un String205
  - 4.3.5 Suppression avec un String207
  - 4.3.6 Recherche et remplacement dans un String209
  - 5. Un mot sur les expressions régulières211
  - Chapitre 10
  - Les vecteurs en langage Rust
  - 1. Introduction215
  - 2. Le vecteur Vec<T>216
  - 2.1 Introduction216
  - 2.2 Accès aux éléments (référence et copie)220
  - 2.3 Méthodes avancées d'accès224
  - 2.4 Considérations sur la taille et la capacité228
  - 2.5 Ajouts et retraits de valeurs230
  - 2.6 Autres opérations sur vecteurs234
  - 2.7 Un mot sur le tri de vecteurs235
  - 2.8 Un mot sur la recherche dans un vecteur237
  - Chapitre 11
  - Autres collections en langage Rust
  - 1. Introduction239
  - 2. La collection VecDeque<T>239
  - 2.1 Présentation239
  - 2.2 Utilisation de VecDeque<T>241
  - 3. La collection LinkedList<T>243
  - 3.1 Présentation243
  - 3.2 Utilisation simple de LinkedList <T>245
  - 4. La collection BinaryHeap<T>247
  - 4.1 Présentation247
  - 4.2 Utilisation de BinaryHeape<T>249
  - 5. Table de hachage HashMap<Key, Value >252
  - 5.1 Présentation252
  - 5.2 Utilisation de HashMap<Key, Value>253
  - 5.3 Un mot sur la collection BTreeMap<Key, Value>254
  - 6. Approche ensembliste avec HashSet<T>256
  - 6.1 Présentation256
  - 6.2 Utilisation de HashSet<T>257
  - 6.3 Un mot sur la collection BTreeSet<T>260
  - 7. Conclusion262
  - Chapitre 12
  - Les closures en Rust
  - 1. Introduction263
  - 2. Considérations théoriques264
  - 3. Première utilisation d'une closure265
  - 4. Tri facile avec une closure266
  - 5. Les closures, résumé des premières notions269
  - 6. Considérations sur les traits FnOnce, FnMut et Fn270
  - 6.1 Explications du fonctionnement général270
  - 6.2 Le mot-clé move271
  - Chapitre 13
  - Les threads et le multithreading en Rust
  - 1. Introduction273
  - 2. Premiers threads et parallélisme274
  - 2.1 Introduction274
  - 2.2 Usage de spawn275
  - 2.2.1 Introduction275
  - 2.2.2 Premier exemple concret275
  - 2.3 Attendre la fin des threads secondaires (Fork-Join)278
  - 2.4 L'alternative rayon281
  - 2.4.1 Premier exemple281
  - 2.4.2 Un peu de parallélisme284
  - 3. Communication entre threads287
  - 3.1 Introduction287
  - 3.2 Usage des canaux en Rust287
  - 3.2.1 Définition287
  - 3.2.2 Première utilisation d'un canal288
  - 3.2.3 Considérations sur la sécurisation du canal289
  - 3.2.4 Envois multiples dans le canal290
  - 4. Usage des verrous mutuels exclusifs294
  - 4.1 Présentation et définition294
  - 4.2 Les structures Rc et Arc295
  - 4.2.1 Introduction295
  - 4.2.2 Rc<T>296
  - 4.2.3 Arc<T>299
  - 4.3 Usage de Mutex301
  - Chapitre 14
  - Rust et WebAssembly
  - 1. Introduction305
  - 1.1 Première considération305
  - 1.2 Explications de WebAssembly305
  - 2. Exemple détaillé de WebAssembly306
  - 2.1 Installation d'outils306
  - 2.2 Exemple détaillé307
  - 2.2.1 Introduction307
  - 2.2.2 Développement côté Rust308
  - 2.2.3 Développement côté JavaScript310
  - 3. Pour aller plus loin318
  - 3.1 Quelques caisses utiles318
  - 3.1.1 Caisse wasm-bindgen318
  - 3.1.2 Caisse console_error_panic_hook319
  - 3.1.3 Caisse console_log319
  - 3.2 Le gestionnaire de paquets npm319
  - 3.2.1 Introduction319
  - 3.2.2 Déploiement sur npm320
  - Chapitre 15
  - Notions avancées en Rust
  - 1. Introduction323
  - 2. Les objets-traits323
  - 2.1 Présentation323
  - 2.2 La surcharge statique324
  - 2.3 La surcharge dynamique326
  - 2.3.1 Introduction326
  - 2.3.2 Contexte de l'exemple326
  - 2.3.3 Définition d'un trait dédiée à la surcharge dynamique327
  - 2.3.4 Usage du mot-clé dyn328
  - 3. Le code Rust non sûr329
  - 3.1 Introduction329
  - 3.2 Déréférencer un pointeur brut330
  - 3.3 Modifier une variable statique mutable332
  - 3.4 Implémenter des traits non sécurisés334
  - Chapitre 16
  - Projet final : coder et publier une caisse
  - 1. Introduction335
  - 2. Périmètre fonctionnel337
  - 3. Développement Rust de la librairie340
  - 4. Autres aspects et tests de la caisse345
  - 5. Publication de la caisse350
  - Index353
Origine de la notice:
- Electre