Accès illimité 24h/24 à tous nos livres & vidéos ! Découvrez la Bibliothèque Numérique ENI. Cliquez ici.
  1. Livres et vidéos
  2. Rust - Développez des programmes robustes et sécurisés

Rust Développez des programmes robustes et sécurisés

  • En stock
  • Expédié en 24h00
  • Livraison à partir de 0,01 €
  • Version en ligne offerte pendant 1 an
  • 1 h d'accès gratuit à tous nos livres et vidéos pour chaque commande
  • Accessible immédiatement et pour une durée de 10 ans
  • Version HTML
  • Accès illimité 24h/24, 7J/7
  • Accès illimité 24h/24, 7J/7
  • Tous les livres en ligne, les vidéos et les cours enregistrés ENI
  • Plus de 10 nouveautés livres et vidéos chaque mois
  • Les nouveautés disponibles le jour de leur sortie
  • Accès 100% en ligne

Présentation

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.


Quizinclus dans
la version en ligne !
  • Testez vos connaissances à l'issue de chaque chapitre
  • Validez vos acquis

Table des matières

  • Comment et pourquoi Rust ?
    • 1. Introduction
    • 2. Contexte d'invention et nature du langage Rust
    • 3. Pourquoi le langage Rust ?
      • 3.1 La question de la gestion de la mémoire
        • 3.1.1 La pile
        • 3.1.2 Le tas
        • 3.1.3 Le typage sûr
      • 3.2 La question de la gestion concurrentielle des threads
        • 3.2.1 Contexte d'utilisation du parallélisme
        • 3.2.2 Situation de compétition
        • 3.2.3 L'enfer de l'exclusion mutuelle
    • 4. Conclusion
  • Commençons à utiliser concrètement Rust
    • 1. Installation et exploration
      • 1.1 L'outil rustup
      • 1.2 L'outil central : cargo
        • 1.2.1 Versions installées
        • 1.2.2 Un premier projet
        • 1.2.3 Analyse et explications relatives au premier projet
        • 1.2.4 Commandes principales cargo
    • 2. Premiers travaux en Rust
      • 2.1 Un premier exemple de programme Rust
      • 2.2 Exécution du programme
      • 2.3 Compléments apportés au programme
    • 3. Outils complémentaires autour du projet réalisé
      • 3.1 Un mot sur les tests unitaires en Rust
      • 3.2 Un mot sur l'organisation par module
      • 3.3 Un mot sur la ligne de commande
    • 4. Nommons les choses - Un peu de vocabulaire
      • 4.1 Introduction
      • 4.2 Petit lexique du langage Rust
        • 4.2.1 Mutabilité
        • 4.2.2 Structure (struct)
        • 4.2.3 Trait et générique
        • 4.2.4 Caisse (crate) et module
        • 4.2.5 Propriété et emprunt
    • 5. Conclusion
  • Types, structures de données en Rust
    • 1. Introduction
    • 2. Les types primitifs simples
      • 2.1 Types numériques entiers
        • 2.1.1 Entiers signés
        • 2.1.2 Entiers non signés
        • 2.1.3 Entiers codés d'après la taille du processeur
      • 2.2 Types numériques flottants
      • 2.3 Le type booléen
      • 2.4 Le type char
    • 3. Les types primitifs, structures de données
      • 3.1 Le tuple
      • 3.2 La structure struct
        • 3.2.1 Structure, cas général
        • 3.2.2 Structure et mutabilité
        • 3.2.3 Le tuple structure
    • 4. Les types pointeurs en Rust
      • 4.1 Références en Rust
      • 4.2 Boîte (box) en Rust
      • 4.3 Pointeurs bruts (raw pointers) en Rust
    • 5. Les types tableaux, vecteurs et tranches
      • 5.1 Introduction
      • 5.2 Les tableaux en Rust
      • 5.3 Les vecteurs en Rust
      • 5.4 Les tranches en Rust
    • 6. Le type chaîne de caractères (string)
      • 6.1 Introduction
      • 6.2 Cas pratique autour de string
    • 7. Conclusion
  • Possession et emprunt en Rust
    • 1. Introduction
      • 1.1 Le tas et la pile
      • 1.2 Utilité de la possession
    • 2. Fonctionnement de la possession
      • 2.1 Grands principes
      • 2.2 Exemples relatifs à la propriété
        • 2.2.1 Propriété dans le tas
        • 2.2.2 Propriété dans la pile
      • 2.3 Plus loin avec la propriété : usage avec fonctions
        • 2.3.1 Passage de valeur à une fonction
        • 2.3.2 Retour de fonction
      • 2.4 Conclusion à propos de la possession
    • 3. Fonctionnement de l'emprunt
      • 3.1 Introduction
      • 3.2 Exemple : transfert de propriété vs emprunt
        • 3.2.1 Transfert de propriété
        • 3.2.2 Emprunt
      • 3.3 Emprunt à base de références mutables
    • 4. Conclusion
  • Structures en Rust
    • 1. Premières structures en Rust
      • 1.1 Introduction
      • 1.2 Structure à champs nommés
        • 1.2.1 Syntaxe
        • 1.2.2 La question de la visibilité
      • 1.3 Structure - tuple
      • 1.4 Structure - unité
      • 1.5 Un mot de l'implantation mémoire d'une structure
    • 2. Les méthodes de structure en Rust
      • 2.1 Prototype des méthodes
      • 2.2 Usage du mot-clé self
      • 2.3 Un exemple d'utilisation des méthodes
      • 2.4 Vers les méthodes statiques en Rust
    • 3. Structure générique
      • 3.1 Introduction
      • 3.2 Exemple support
      • 3.3 Exemple support augmenté
    • 4. La question des références dans une structure
      • 4.1 Introduction
      • 4.2 Mise en évidence du besoin d'annotation de durée de vie
      • 4.3 Durée de vie basée sur le mot-clé static
    • 5. Notion de traits appliqués aux structures
      • 5.1 Introduction
      • 5.2 Les traits prédéfinis appliqués aux structures
    • 6. Conclusion
  • Énumérations et motifs en Rust
    • 1. Introduction
    • 2. Les énumérations en Rust
      • 2.1 Premiers exemples
      • 2.2 Exemple de conversion d'entiers vers une énumération
        • 2.2.1 Les options dans la librairie standard
        • 2.2.2 Premiers filtrages par motif
      • 2.3 Un mot sur les méthodes d'énumération
      • 2.4 Utiliser des structures dans des énumérations
        • 2.4.1 Introduction
        • 2.4.2 Exemple d'utilisation
      • 2.5 Les énumérations génériques
        • 2.5.1 Exemple dans la librairie standard
        • 2.5.2 Arbre binaire avec une énumération générique
    • 3. Filtrage par motif
      • 3.1 Premier exemple, pour rappel
      • 3.2 Plus loin avec les motifs
  • Les traits en Rust
    • 1. Introduction
    • 2. Premier trait en Rust
      • 2.1 Création d'une caisse et d'un exécutable client
      • 2.2 Définition d'un trait
    • 3. Utiliser un trait en paramètre
      • 3.1 Introduction
      • 3.2 Exemple de trait en paramètre
      • 3.3 Plusieurs paramètres d'un même trait en paramètre
    • 4. Notion de trait lié
      • 4.1 Introduction
      • 4.2 Plusieurs traits liés différents pour un même paramètre
        • 4.2.1 Introduction
        • 4.2.2 Le trait prédéfini Display
        • 4.2.3 Création de la structure Tortue
        • 4.2.4 Un mot sur la clause where
    • 5. Un trait comme valeur de retour
      • 5.1 Introduction
      • 5.2 Exemple support
    • 6. Points d'architecture impliquant les traits
      • 6.1 Traits, génériques et structures
      • 6.2 Un mot sur les sous-traits
  • Les traits prédéfinis en Rust
    • 1. Introduction
    • 2. Des traits prédéfinis essentiels : les itérateurs
    • 3. Notion de surcharge d'opérateurs
      • 3.1 Introduction
      • 3.2 Les opérateurs surchargeables
      • 3.3 Exemple support
        • 3.3.1 Contexte des nombres complexes
        • 3.3.2 Premiers éléments de programmation
        • 3.3.3 Surcharges des opérateurs + et -
        • 3.3.4 Surcharges de la comparaison
    • 4. Inventaire et usage de quelques traits prédéfinis
      • 4.1 L'usage de Derive
        • 4.1.1 Explications
        • 4.1.2 Exemple support
      • 4.2 Inventaire des traits
        • 4.2.1 Introduction
        • 4.2.2 Le trait Drop
        • 4.2.3 Les traits Deref et DerefMut
        • 4.2.4 Le trait Default
        • 4.2.5 Le trait From
  • Les chaînes de caractères en Rust
    • 1. Introduction
    • 2. Encodages Unicode et UTF-8 et caractères en Rust
      • 2.1 Quelques définitions
      • 2.2 Encodage en Rust
        • 2.2.1 Le type char et l'Unicode
        • 2.2.2 Les types String et str et l'UTF-8
    • 3. À la découverte des caractères (char) en Rust
      • 3.1 Nature des caractères
      • 3.2 Casse des caractères
      • 3.3 Conversion vers un entier
    • 4. À la découverte de String et str
      • 4.1 Introduction
      • 4.2 Le type str
      • 4.3 Le type String
        • 4.3.1 Construction du type
        • 4.3.2 Création d'un String
        • 4.3.3 Premiers outils autour de String
        • 4.3.4 Insertion dans un String
        • 4.3.5 Suppression avec un String
        • 4.3.6 Recherche et remplacement dans un String
    • 5. Un mot sur les expressions régulières
  • Les vecteurs en langage Rust
    • 1. Introduction
    • 2. Le vecteur Vec<T>
      • 2.1 Introduction
      • 2.2 Accès aux éléments (référence et copie)
      • 2.3 Méthodes avancées d'accès
      • 2.4 Considérations sur la taille et la capacité
      • 2.5 Ajouts et retraits de valeurs
      • 2.6 Autres opérations sur vecteurs
      • 2.7 Un mot sur le tri de vecteurs
      • 2.8 Un mot sur la recherche dans un vecteur
  • Autres collections en langage Rust
    • 1. Introduction
    • 2. La collection VecDeque<T>
      • 2.1 Présentation
      • 2.2 Utilisation de VecDeque<T>
    • 3. La collection LinkedList<T>
      • 3.1 Présentation
      • 3.2 Utilisation simple de LinkedList<T>
    • 4. La collection BinaryHeap<T>
      • 4.1 Présentation
      • 4.2 Utilisation de BinaryHeap<T>
    • 5. Table de hachage HashMap<Key, Value>
      • 5.1 Présentation
      • 5.2 Utilisation de HashMap<Key, Value>
      • 5.3 Un mot sur la collection BTreeMap<Key, Value>
    • 6. Approche ensembliste avec HashSet<T>
      • 6.1 Présentation
      • 6.2 Utilisation de HashSet<T>
      • 6.3 Un mot sur la collection BTreeSet<T>
    • 7. Conclusion
  • Les closures en Rust
    • 1. Introduction
    • 2. Considérations théoriques
    • 3. Première utilisation d'une closure
    • 4. Tri facile avec une closure
    • 5. Les closures, résumé des premières notions
    • 6. Considérations sur les traits FnOnce, FnMut et Fn
      • 6.1 Explications du fonctionnement général
      • 6.2 Le mot-clé move
  • Les threads et le multithreading en Rust
    • 1. Introduction
    • 2. Premiers threads et parallélisme
      • 2.1 Introduction
      • 2.2 Usage de spawn
        • 2.2.1 Introduction
        • 2.2.2 Premier exemple concret
      • 2.3 Attendre la fin des threads secondaires (Fork-Join)
      • 2.4 L'alternative rayon
        • 2.4.1 Premier exemple
        • 2.4.2 Un peu de parallélisme
    • 3. Communication entre threads
      • 3.1 Introduction
      • 3.2 Usage des canaux en Rust
        • 3.2.1 Définition
        • 3.2.2 Première utilisation d'un canal
        • 3.2.3 Considérations sur la sécurisation du canal
        • 3.2.4 Envois multiples dans le canal
    • 4. Usage des verrous mutuels exclusifs
      • 4.1 Présentation et définition
      • 4.2 Les structures Rc et Arc
        • 4.2.1 Introduction
        • 4.2.2 Rc<T>
        • 4.2.3 Arc<T>
      • 4.3 Usage de Mutex
  • Rust et WebAssembly
    • 1. Introduction
      • 1.1 Première considération
      • 1.2 Explications de WebAssembly
    • 2. Exemple détaillé de WebAssembly
      • 2.1 Installation d'outils
      • 2.2 Exemple détaillé
        • 2.2.1 Introduction
        • 2.2.2 Développement côté Rust
        • 2.2.3 Développement côté JavaScript
    • 3. Pour aller plus loin
      • 3.1 Quelques caisses utiles
        • 3.1.1 Caisse wasm-bindgen
        • 3.1.2 Caisse console_error_panic_hook
        • 3.1.3 Caisse console_log
      • 3.2 Le gestionnaire de paquets npm
        • 3.2.1 Introduction
        • 3.2.2 Déploiement sur npm
  • Notions avancées en Rust
    • 1. Introduction
    • 2. Les objets-traits
      • 2.1 Présentation
      • 2.2 La surcharge statique
      • 2.3 La surcharge dynamique
        • 2.3.1 Introduction
        • 2.3.2 Contexte de l'exemple
        • 2.3.3 Définition d'un trait dédiée à la surcharge dynamique
        • 2.3.4 Usage du mot-clé dyn
    • 3. Le code Rust non sûr
      • 3.1 Introduction
      • 3.2 Déréférencer un pointeur brut
      • 3.3 Modifier une variable statique mutable
      • 3.4 Implémenter des traits non sécurisés
  • Projet final : coder et publier une caisse
    • 1. Introduction
    • 2. Périmètre fonctionnel
    • 3. Développement Rust de la librairie
    • 4. Autres aspects et tests de la caisse
    • 5. Publication de la caisse
    • Index

Auteur

Benoît PRIEUREn savoir plus

Ingénieur en informatique diplômé de l'ISIMA de Clermont-Ferrand, Benoît PRIEUR est développeur freelance et conduit des missions de conseil en particulier sur les technologies C#/.Net, Python et Rust. Il intervient notamment sur des sujets relatifs au Machine Learning. Il est également formateur et conférencier sur diverses technologies (l’informatique quantique notamment) et auteur régulier d'articles sur la programmation de logiciels.

Caractéristiques

  • Niveau Confirmé à Expert
  • Nombre de pages 362 pages
  • Parution mai 2022
    • Livre (broché) - 17 x 21 cm
    • ISBN : 978-2-409-03528-9
    • EAN : 9782409035289
    • Ref. ENI : EIRUST
  • Niveau Expert à Confirmé
  • Parution mai 2022
    • HTML
    • ISBN : 978-2-409-03529-6
    • EAN : 9782409035296
    • Ref. ENI : LNEIRUST

Téléchargements

En complétant ce formulaire, vous acceptez d'être contacté afin de recevoir des informations sur nos produits et services ainsi que nos communications marketing. Vous aurez la possibilité de vous désabonner de nos communications à tout moment. Pour plus d'informations sur notre politique de protection des données, cliquez ici.
  • Des fichiers complémentaires (31 870 Ko)