Concepts et sémantique des langages de programmation. 2 , Constructions modulaires et objet avec OCaml, Python, C ++, Ada et Java

Résumé

Ce second volume présente un modèle sémantique adapté aux constructions et aux opérations des modules et des classes, telles que l'importation, la visibilité, les extensions ou la paramétrisation par types et valeurs. Ce modèle est décliné pour modéliser les traits objet et traiter les classes des langages de programmation courants comme Java, C ++ et Python. ©Electre 2020

Contributeur(s)
- Dowek, Gilles (1966-....). Préfacier, etc.
- Dubois, Catherine (1963-....). Préfacier, etc.
Éditeur(s)
- Iste éditions
Date
- C 2020
Notes
- Autre contributeur : Véronique Viguié Donzeau-Gouge (Auteure)
Langues
- Français
Description matérielle
- 1 vol. (VII-241 p.) ; 24 cm
Collections
- Informatique
Sujet(s)
ISBN
- 978-1-78405-702-2
Indice
- 681.2 Programmation (généralités)
Quatrième de couverture
- Cet ouvrage explore les constructions syntaxiques des langages de programmation les plus courants, avec un éclairage mathématique sur leurs sémantiques et une présentation précise des aspects matériels qui interfèrent avec le codage.
  Ce deuxième volume présente un modèle sémantique original commun aux constructions et opérations des modules et des classes : visibilité, importation, exportation, définitions différées, paramétrisation par types et valeurs, extensions. Ce modèle fonde l'étude des modules d'Ada, OCaml et des fichiers d'en-tête de C. Il est décliné pour modéliser les traits objet puis utilisé pour traiter les classes de C++, Java, Python et OCaml.
  Concepts et sémantique des langages de programmation 2 s'adresse aux étudiants et enseignants des cursus informatiques ainsi qu'aux programmeurs chevronnés, qui y trouveront un guide de lecture des manuels de référence ainsi que les fondements de la vérification de programmes.
Tables des matières
- - Concepts et sémantique des langages de programmation 2
  - Constructions modulaires et objet avec OCaml, Python, C++ Ada et Java
  - Thérèse Hardin
  - Mathieu Jaume
  - François Pessaux
  - Véronique Viguié Donzeau-Gouge
  - Iste editions
  - Préface1
  - Gilles Dowek et Catherine Dubois
  - Avant-propos3
  - Chapitre 1. Gestion des noms : modèle et opérations5
  - 1.1. Réutiliser, découper, confiner6
  - 1.1.1. Analyse des besoins6
  - 1.1.2. Répondre à ces besoins7
  - 1.2. Espaces de noms9
  - 1.2.1. Définition des espaces de noms10
  - 1.2.2. Extension de la notion d'environnement et de liaison12
  - 1.3. Développement des kits16
  - 1.3.1. Espace des noms d'un kit18
  - 1.3.2. Hypothèses d'étude18
  - 1.3.3. Type d'un kit19
  - 1.3.4. Valeur d'un kit22
  - 1.3.5. Exportation d'un kit, confinement de champs25
  - 1.3.6. Importation d'un to31
  - 1.3.7. Étapes de développement36
  - 1.4. Kits incomplets36
  - 1.4.1. Type et valeur d'un kit incomplet37
  - 1.4.2. Complétion d'un to incomplet37
  - 1.4.3. Confinement de champs d'un to incomplet38
  - 1.5. Kits paramétrés39
  - 1.5.1. Kits paramétrés par un type39
  - 1.5.2. Kits paramétrés par un type et une valeur43
  - 1.5.3. Confinement, paramétrage, kits incomplets et exportation47
  - 1.6. Fondeurs de kit48
  - 1.7. Extension d'un kit51
  - 1.7.1. Présentation de l'extension51
  - 1.7.2. Confinement et extension56
  - 1.8. Commentaires sur le modèle de kit61
  - Chapitre 2. Les modules63
  - 2.1. Les modules en Ada64
  - 2.1.1. Développement des modules64
  - 2.1.2. Exportation et confinement67
  - 2.1.3. Imbrication de modules68
  - 2.1.4. Importation d'un module68
  - 2.1.5. Étalement d'une importation69
  - 2.1.6. Modules génériques70
  - 2.1.7. Modules et compilation séparée74
  - 2.2. Les modules en OCaml74
  - 2.2.1. Définition d'un module75
  - 2.2.2. Exportation et confinement76
  - 2.2.3. Confinement des définitions de types81
  - 2.2.4. Fondeurs85
  - 2.3. Modularité, espaces de noms et W-kit88
  - 2.3.1. Interfaces de déclaration89
  - 2.3.2. W-kit89
  - 2.3.3. Modularité et fichiers d'en-tête en C89
  - Chapitre 3. Traits orientés objet95
  - 3.1. Principaux traits objet95
  - 3.1.1. Objets96
  - 3.1.2. Classes98
  - 3.2. Kits et traits objet106
  - 3.2.1. Modéliser les classes107
  - 3.2.2. Modéliser les objets109
  - 3.2.3. Héritage, redéfinition et liaison retardée112
  - 3.2.4. C-kits incomplets, C-kits paramétrés116
  - 3.2.5. Héritage, sous-classage, sous-typage117
  - 3.2.6. Langages de types, classes et objets121
  - Chapitre 4. Les classes dans différents langages125
  - 4.1. Les classes de Java125
  - 4.1.1. Présentation125
  - 4.1.2. Modules et packages126
  - 4.1.3. Classes127
  - 4.1.4. Marques133
  - 4.1.5. Développement de classes136
  - 4.2. Les classes de C++146
  - 4.2.1. Fichiers d'en-tête, espace de noms, confinement146
  - 4.2.2. Un tour des classes150
  - 4.2.3. Héritage et confinement156
  - 4.2.4. Surcharge en C++167
  - 4.2.5. Classes paramétrées170
  - 4.3. Les classes de OCaml176
  - 4.3.1. Présentation176
  - 4.3.2. Un tour des classes176
  - 4.3.3. Marques, classes incomplètes, paramétrisation182
  - 4.3.4. Objets186
  - 4.3.5. Signatures de classe : confinement et héritage192
  - 4.3.6. Héritage multiple195
  - 4.3.7. Autres traits197
  - 4.4. Les classes de Python198
  - 4.4.1. Présentation198
  - 4.4.2. Un tour des classes, modules et types199
  - 4.4.3. Noms et affectation208
  - 4.4.4. Affectation et typage212
  - 4.4.5. Surcharge214
  - 4.4.6. Modules et packages218
  - 4.4.7. Confinement220
  - 4.4.8. Héritage220
  - 4.4.9. C-kits incomplets et classes abstraites223
  - 4.4.10. Autres traits224
  - Annexe. Questions pour étudier un langage227
  - Liste des notations231
  - Bibliographie233
  - Index235
  - Sommaire de Concepts et sémantique des langages de programmation 1239
Origine de la notice:
- Electre