1. Livres et vidéos
  2. Langage C++ - L'héritage du C et la programmation orientée objet (avec programmes d'illustration et exercices)

Langage C++ L'héritage du C et la programmation orientée objet (avec programmes d'illustration et exercices)

  • 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
  • En stock
  • Expédié en 24h00
  • Livraison à partir de 0,01 €
  • Version en ligne offerte
  • 1 h d'accès gratuit à tous nos livres et vidéos pour chaque commande
  • Accessible immédiatement
  • Version HTML
  • Accès illimité 24h/24, 7J/7

Présentation

Le C++ fascine par l'infini des réalisations et des manières de programmer qu'il permet. D'une part il hérite du langage C qui lui procure une base pour tout ce qui concerne l'écriture algorithmique, et d'autre part il est doté de puissants outils de structuration orientés objet.

Ce livre sur le langage C++ s'adresse aux personnes qui débutent avec C++ et ayant déjà programmé dans d'autres langages.

Le livre se divise en deux parties. Dans la première, l'auteur traite de notions qui concernent l'écriture algorithmique et ses fondamentaux : variables, opérations, structures de contrôle (if, switch, boucles, fonctions), ensembles de variables (structures et tableaux), pointeurs... En bref, il s'agit du langage C intégré au langage C++. L'auteur expose les correctifs et les élargissements fonctionnels apportés par le C++. Les classes et les objets commencent à apparaître avec la notion de structures. Les améliorations apportées par le C++ sont mises en pratique dans la réalisation de programmes au fur et à mesure de leur introduction.

Dans une deuxième partie se trouve ce qui fait la force du C++ : l'auteur présente ainsi des outils de structuration qui permettent au lecteur de s'orienter franchement vers la programmation et l'architecture objet des programmes. Il y détaille les notions de classes (constructeurs, destructeurs), d'objets, la problématique de relations entre objets, l'héritage, la problématique du polymorphisme avec virtualité, les notions de classe abstraite et d'interface… L'ensemble des fonctionnalités associées à ces différents concepts sont étudiées.

Pour finir, un chapitre compare le C et le C++. Certains outils comme les pointeurs et les paramètres de fonctions peuvent en effet s'interpréter différemment dans des situations créées par l'un ou l'autre des deux langages. Ce chapitre permet ainsi au lecteur de pallier la difficulté de passer d'un langage à l'autre en prenant en compte ces différences d'interprétation.

Tout au long du livre, l'auteur fournit une série d'exercices diversifiés et des exemples de programmes apportant la mise en pratique nécessaire pour s'approprier le langage. Les éléments nécessaires à la réalisation des exercices sont en téléchargement sur le site www.editions-eni.fr.


Les chapitres du livre :
Partie C++ hérité du C : Introduction – Premiers programmes – Variables simples, constantes, affectation – Affichage et saisie console – Opérations – Conversions de types – Structures de contrôle – Fonctions – Portée et durée de vie des variables – Structures – Bibliothèques et espaces de noms – Unions – Tableaux statiques – Chaînes de caractères – Pointeurs – Principales utilisations des pointeurs – Gestion des erreurs – Deux automates cellulaires – Partie La dimension objet du C++ : Classes, objets – Surcharge des opérateurs – Classes et membres static – Classes génériques – Classe d'objets changeants – Associations entre objets – Héritage – Polymorphisme et virtualité – Classe abstraite et interface – Quelques comparaisons entre C et C++

Table des matières

  • Introduction
    • 1. Le C++ au pied de la lettre
    • 2. Cartographie de la grammaire C++
    • 3. Organisation du livre
    • 4. Modalités de comparaison C/C++
    • 5. Public visé
    • 6. Clés pour apprendre
    • 7. Environnements de développement
  • Premiers programmes
    • 1. C inclus en C++
    • 2. La fonction main() : entrée du programme
    • 3. "Hello world !" en C
    • 4. "Hello world !"en C++
      • 4.1 Bibliothèque <iostream>, directive #include
      • 4.2 L'instruction using namespace std;
      • 4.3 Inclusion des bibliothèques C en C++
  • Variables simples, constantes, affectation
    • 1. Introduction
    • 2. Socle C
      • 2.1 Différents types de variables
      • 2.2 Déclaration des variables
      • 2.3 Affecter et afficher une valeur (avec cout qui est C++)
      • 2.4 Caractères, codage ASCII
      • 2.5 Variables constantes
      • 2.6 Énumérations
      • 2.7 Directive #define
      • 2.8 Opérateur Sizeof
    • 3. Apports C++
      • 3.1 Déclarations plus souples
      • 3.2 Type bool
      • 3.3 Type long long ou unsigned long long
      • 3.4 Type caractère unicode : wchar_t
      • 3.5 Type auto (C++ 2011)
      • 3.6 Constantes (const) et énumération (enum) plutôt que #define
  • Affichage et saisie console
    • 1. Socle C
      • 1.1 Fonction printf (déconseillé en C++)
      • 1.2 Fonctions sprintf et snprintf
      • 1.3 Fonction scanf (déconseillé en C++)
    • 2. Apports C++
      • 2.1 Utiliser cout et cin
      • 2.2 Instructions de formatage en sortie
        • 2.2.1 Largeur minimum de l'affichage
        • 2.2.2 Alignement des sorties
        • 2.2.3 Choisir un caractère de remplissage
        • 2.2.4 Afficher ou non les zéros après la virgule
        • 2.2.5 Afficher le signe des nombres positifs
  • Opérations
    • 1. Socle C
      • 1.1 Notion d'expression
      • 1.2 Opérations arithmétiques
      • 1.3 Valeurs aléatoires
        • 1.3.1 Avoir des suites différentes
        • 1.3.2 Définir une fourchette
      • 1.4 Opérations bit à bit
        • 1.4.1 ET : opérateur &
        • 1.4.2 OU exclusif : opérateur ^
        • 1.4.3 OU inclusif : opérateur |
        • 1.4.4 Complément : opérateur ~
        • 1.4.5 Décalages gauche et droite : opérateurs >> et <<
        • 1.4.6 Priorités des opérateurs bit à bit
    • 2. Apports C++
      • 2.1 Surcharger les opérateurs
  • Conversions de types
    • 1. Socle hérité du C
      • 1.1 Le principe
      • 1.2 Opérateur de conversion
      • 1.3 Exemple : nombre aléatoire avec décimales
    • 2. Apports du C++
      • 2.1 static_cast<type>
      • 2.2 const_cast<type>
      • 2.3 reinterpret_cast<type>
      • 2.4 dynamic_cast<type>
  • Structures de contrôle
    • 1. Socle hérité du C
      • 1.1 Bloc d'instructions
      • 1.2 L'instruction conditionnelle if
      • 1.3 Définir une condition
        • 1.3.1 Opérateurs de comparaisons
        • 1.3.2 L'opérateur unaire NON : !
      • 1.4 Le couple d'instructions if-else
      • 1.5 La forme contractée du if-else, opérateur conditionnel "?"
      • 1.6 La cascade d'instructions if - else if - else
      • 1.7 Les tests multiconditions (ET/OU)
        • 1.7.1 Conjonction ET : opérateur &&
        • 1.7.2 ET avec plus de deux expressions membres
        • 1.7.3 Disjonction OU, opérateur ||
        • 1.7.4 OU avec plus de deux expressions membres
        • 1.7.5 ET prioritaire sur OU
      • 1.8 Branchement : switch
      • 1.9 Rupture de séquence : goto avec étiquette
      • 1.10 Les trois boucles : while, do-while et for
        • 1.10.1 Boucle TANT QUE : le while
        • 1.10.2 Boucle FAIRE {...} TANT QUE : le do-while
        • 1.10.3 Boucle comptée POUR : le for
        • 1.10.4 Boucles imbriquées
      • 1.11 Sortie et saut forcés dans une boucle
        • 1.11.1 Sortir avec l'instruction break
        • 1.11.2 Passer à l'itération suivante avec l'instruction continue
        • 1.11.3 Sortir d'une ou de plusieurs boucles imbriquées avec l'instruction goto
    • 2. Apports du C++
      • 2.1 Boucle for (:) "pour chaque"
  • Fonctions
    • 1. Socle hérité du C
      • 1.1 Principe
      • 1.2 Exemple de fonction sans retour et sans paramètre
      • 1.3 Déclaration et visibilité d'une fonction
      • 1.4 Exemples de fonction avec paramètres
        • 1.4.1 Déplacer le curseur en écriture de la fenêtre console
        • 1.4.2 Changer la couleur des caractères
        • 1.4.3 À propos de la couleur en console
        • 1.4.4 Afficher une lettre à une position et d'une couleur donnée dans la console
        • 1.4.5 Tracer une ligne horizontale
        • 1.4.6 Le programme complet
      • 1.5 Exemples de fonction avec retour
        • 1.5.1 Retourner un nombre aléatoire entre 0 et 1
        • 1.5.2 Retourner le résultat d'un jeté de deux dés à six faces
        • 1.5.3 Programme complet
      • 1.6 Exemple de fonction avec retour et avec paramètres
        • 1.6.1 Conversion chiffres romains
    • 2. Apports du C++
      • 2.1 Fonctions embarquées "inline"
      • 2.2 Valeurs par défaut de paramètres
      • 2.3 Surcharge des fonctions
      • 2.4 Fonctions génériques (template)
  • Portée et durée de vie des variables
    • 1. Règles
    • 2. Masquage d'une variable
    • 3. Variables static
  • Structures
    • 1. Socle hérité du C
      • 1.1 Principe de la structure
      • 1.2 Disposer d'une structure / entite 1
        • 1.2.1 Définir un type de structure
        • 1.2.2 Déclarer une variable structure
        • 1.2.3 Initialiser à la déclaration
        • 1.2.4 Accéder aux éléments avec l'opérateur point
      • 1.3 Utiliser un typedef
      • 1.4 Structures en retour ou en paramètre de fonction
        • 1.4.1 Fonction d'initialisation d'une entite
        • 1.4.2 Fonctions d'affichage et d'effacement
        • 1.4.3 Fonction pour avancer
        • 1.4.4 Boucle événementielle
        • 1.4.5 Contrôle du rythme de l'animation
        • 1.4.6 Rendre invisible le curseur en écriture
        • 1.4.7 Programme complet
      • 1.5 Structures imbriquées
    • 2. Apports du C++
      • 2.1 typedef inutile pour les structures
      • 2.2 Fonctions comme champs de structures
      • 2.3 La structure C++ synonyme de classe
      • 2.4 Conclusion : des classes plutôt que des structures
  • Bibliothèques et espaces de noms
    • 1. Créer une bibliothèque (.h)
      • 1.1 Contenu du fichier outils.h
      • 1.2 Contenu du fichier outils.cpp
      • 1.3 Contenu du fichier main.cpp
    • 2. Espaces de noms (namespace) et raccourcis (using)
      • 2.1 Cartographier le code
      • 2.2 Accéder au contenu
      • 2.3 Répartir le code
      • 2.4 Limite des répartitions
      • 2.5 Espace de noms dans une bibliothèque
      • 2.6 Imbriquer des espaces de noms
    • 3. La directive using
    • 4. Précision sur la liaison entre C++ et C
  • Unions
    • 1. Principe
    • 2. Unions discriminées : exemple météo
  • Tableaux statiques
    • 1. Socle hérité du C
      • 1.1 Principe du tableau
      • 1.2 Disposer d'un tableau
        • 1.2.1 Définir et déclarer un tableau
        • 1.2.2 Des constantes pour les tailles
        • 1.2.3 Accéder aux éléments du tableau avec l'opérateur [ ]
        • 1.2.4 Débordement de tableau
        • 1.2.5 Initialiser un tableau à la déclaration
        • 1.2.6 Parcourir un tableau avec une boucle for
      • 1.3 Tableaux à plusieurs dimensions
        • 1.3.1 Matrice à deux dimensions
        • 1.3.2 Tableaux à N dimensions
        • 1.3.3 Initialiser à la déclaration
        • 1.3.4 Parcourir un tableau à plusieurs dimensions
      • 1.4 Tableaux comme champ dans une structure
      • 1.5 Tableaux de structures
      • 1.6 Tableaux d'unions
      • 1.7 Tableaux et fonctions
        • 1.7.1 Tableaux en global avec fonctions dédiées
        • 1.7.2 Pointeur en paramètre
    • 2. Apports du C++
      • 2.1 Boucle for (:) "pour chaque"
      • 2.2 Tableaux d'objets
        • 2.2.1 Initialiseurs
        • 2.2.2 Fonction reset
      • 2.3 Tableau dans une classe
        • 2.3.1 La classe fourmi
        • 2.3.2 La classe fourmiliere
      • 2.4 Les conteneurs : rapide introduction
        • 2.4.1 La classe array
        • 2.4.2 La classe vector
        • 2.4.3 La classe list
  • Chaînes de caractères
    • 1. Socle hérité du C
    • 2. Apports du C++ : la classe string
  • Pointeurs
    • 1. Introduction
    • 2. Brève description théorique du pointeur
      • 2.1 Adresse mémoire
      • 2.2 Une variable pointeur
      • 2.3 Quatre opérateurs dédiés
      • 2.4 Cinq utilisations fondamentales
        • 2.4.1 En paramètre de fonction
        • 2.4.2 Allocation dynamique (éléments seuls ou tableaux d’éléments)
        • 2.4.3 Établir des relations entre structures, classes ou objets
        • 2.4.4 Élaborer des listes chaînées, des arbres, des graphes
        • 2.4.5 Établir un polymorphisme de classe (C++ uniquement)
    • 3. Socle hérité du C
      • 3.1 Déclarer un pointeur dans un programme
      • 3.2 Opérateur adresse : &
      • 3.3 Opérateur étoile : *
      • 3.4 Opérateur flèche : ->
      • 3.5 Opérateur crochet : [ ]
      • 3.6 Priorité des quatre opérateurs
      • 3.7 Fonctions C d'allocation dynamique (déconseillées en C++)
        • 3.7.1 La fonction malloc()
        • 3.7.2 Libérer la mémoire allouée : la fonction free()
      • 3.8 Le pointeur générique void*
      • 3.9 La valeur NULL (déconseillée en C++)
      • 3.10 Pointeurs et constantes
        • 3.10.1 Pointeur variable sur un objet constant
        • 3.10.2 Pointeur constant sur un objet variable
        • 3.10.3 Pointeur constant sur un objet constant
      • 3.11 Cas des pointeurs de fonction
        • 3.11.1 Une fonction est une adresse
        • 3.11.2 Reconnaître un type de fonction
        • 3.11.3 Appeler une fonction via un pointeur du bon type
        • 3.11.4 Cast nécessaire si le pointeur est un void*
        • 3.11.5 Pourquoi des pointeurs de fonction ? Les callbacks
    • 4. Apports du C++
      • 4.1 Type référence (pointeur masqué)
        • 4.1.1 Une référence est constante
        • 4.1.2 Connaître la valeur de la référence
      • 4.2 Retourner une référence
        • 4.2.1 Piège à éviter
        • 4.2.2 Masquer un tableau avec une fonction
      • 4.3 Opérateurs new et delete, new[ ] et delete[ ]
      • 4.4 Précisions sur l'opérateur new (C++2011)
      • 4.5 La valeur nullptr (remplace NULL)
      • 4.6 Un souci de rigueur
  • Principales utilisations des pointeurs
    • 1. Pointeur en paramètre (passage par référence)
      • 1.1 Expérimentation avec pointeur classique
      • 1.2 Simplification de l'écriture avec des références C++
      • 1.3 Passage avec référence C++ de structures
      • 1.4 Tableau en paramètre
        • 1.4.1 Tableau à une dimension
        • 1.4.2 Tableaux à plusieurs dimensions
    • 2. Allocation dynamique
      • 2.1 Structures ou objets dynamiques
        • 2.1.1 Version structures C
        • 2.1.2 Version objets C++
      • 2.2 Utiliser un tableau de pointeurs
        • 2.2.1 Tableau de pointeurs de structures C
        • 2.2.2 Tableau de pointeurs d'objets C++
      • 2.3 Validité d'une adresse mémoire
    • 3. Allocation dynamique de tableaux
      • 3.1 Tableaux dynamiques une dimension
        • 3.1.1 Tableau dynamique de int
        • 3.1.2 Tableau dynamique dans une classe
      • 3.2 Tableaux dynamiques de plusieurs dimensions
        • 3.2.1 Allocation dynamique d'une matrice de int
        • 3.2.2 Allocation dynamique d'une forme à 6 dimensions de points
    • 4. Associer des structures ou des classes
      • 4.1 Association de deux structures C de types différents
        • 4.1.1 Structures avion et pilote
        • 4.1.2 Relier avion et pilote
        • 4.1.3 Délier un avion et un pilote
        • 4.1.4 Constructeurs avion et pilote
        • 4.1.5 Afficher Avion et Pilote
        • 4.1.6 Détruire un Avion ou un Pilote
        • 4.1.7 Main action
      • 4.2 Association de structures C de même type
    • 5. Élaborer une liste
  • Gestion des erreurs
    • 1. Introduction
    • 2. Socle hérité du C
      • 2.1 Retourner un booléen
      • 2.2 Retourner un numéro d'erreur
      • 2.3 Afficher des informations au moment de l'erreur
    • 3. Fonctionnement et syntaxe des exceptions C++
      • 3.1 Instruction throw
      • 3.2 Instruction de saut try-catch
      • 3.3 Instruction throw et appels de fonctions
      • 3.4 Instruction throw sans valeur de retour
      • 3.5 Bloc catch(...) par défaut
      • 3.6 Exception non gérée
      • 3.7 La fonction terminate
      • 3.8 La fonction unexpected
    • 4. Utilisation de la classe exception
      • 4.1 Utiliser les exceptions standards du C++
      • 4.2 Mise à jour de outils.h
        • 4.2.1 Formalisme et style de la présentation
        • 4.2.2 Contrôle d'erreur dans la fonction GetStdout
        • 4.2.3 Contrôle d'une taille minimum de fenêtre pour ConsoleResize()
        • 4.2.4 Possibles exceptions dans ConsoleResize()
      • 4.3 Conseil sur les exceptions
  • Deux automates cellulaires
    • 1. Introduction
    • 2. Simulation de feux de forêt
      • 2.1 Principe
      • 2.2 Mise en forme et initialisation
        • 2.2.1 Structures de données
        • 2.2.2 Dimensionner la console et les deux matrices
        • 2.2.3 Initialisation des bois
        • 2.2.4 Initialisation du feu
      • 2.3 Afficher
        • 2.3.1 Premier type d'affichage, lent
        • 2.3.2 Affichage très rapide direct mémoire
      • 2.4 Processus générateur
        • 2.4.1 Fonction de propagation
        • 2.4.2 Boucle du processus
        • 2.4.3 Destruction des matrices
      • 2.5 Texte complet du programme
      • 2.6 Perspectives
    • 3. Automate cellulaire type Conway
      • 3.1 Principe
      • 3.2 Mise en forme et initialisation
        • 3.2.1 Structures de données de l'automate
        • 3.2.2 Déterminer la taille de la fenêtre console
        • 3.2.3 Allocation et initialisation des matrices
      • 3.3 Processus générateur
        • 3.3.1 Fonction calcul
        • 3.3.2 Comptage des voisins
        • 3.3.3 Recopie
      • 3.4 Afficher
        • 3.4.1 Première version : affichage lent
        • 3.4.2 Affichage direct mémoire : rapide
      • 3.5 Texte complet du programme
      • 3.6 Possibles gels ou mort de l'automate
  • Classes, objets
    • 1. Introduction
    • 2. Une classe, des objets
      • 2.1 Qu'est-ce qu’une classe ?
      • 2.2 Qu'est-ce qu’un objet ?
      • 2.3 Définir une classe
      • 2.4 Déclarer un objet
      • 2.5 Droits d'accès
      • 2.6 Le pointeur this
    • 3. Un programme C muté en classe et objet
    • 4. Retour sur la conception du programme
      • 4.1 La dimension objet de l'automate
      • 4.2 La dimension objet de la fenêtre console
    • 5. Constructeurs
      • 5.1 Syntaxe d'un constructeur
      • 5.2 Constructeur sans paramètre
      • 5.3 Constructeurs avec paramètres
      • 5.4 Constructeur et initialiseur
        • 5.4.1 Une seule variable
        • 5.4.2 Plusieurs variables
        • 5.4.3 Des variables de types différents
        • 5.4.4 Exemple classe Tab
        • 5.4.5 L'initialiseur initialise les constantes dans une classe
      • 5.5 Constructeur par défaut
    • 6. Constructeur de copie
      • 6.1 Copier un objet à la déclaration
      • 6.2 Problème des données dynamiques
      • 6.3 Implémenter son constructeur de copie
    • 7. Constructeur de déplacement (C++2011)
      • 7.1 Lvalue et Rvalue
      • 7.2 Problème de transfert lors des passages d'arguments
      • 7.3 Déclarateur de référence Rvalue &&
      • 7.4 Conversions en Rvalue : static_cast<>(), fonctions move() et forward<>()
      • 7.5 Constructeur de déplacement
      • 7.6 Constructeur de déplacement avec des données dynamiques
    • 8. Affectation (operateur =)
      • 8.1 Affectation de copie
      • 8.2 Affectation de déplacement (C++2011)
    • 9. Destructeur
      • 9.1 Libérer la mémoire allouée
      • 9.2 Destructeur appelé avec delete
      • 9.3 Programme complet de l'automate en objet C++
    • 10. default et delete pour les fonctions spéciales de classe (C++2011)
      • 10.1 Fonctions spéciales
      • 10.2 Utiliser default
      • 10.3 Utiliser delete
    • 11. Accesseurs (property en anglais)
      • 11.1 Accéder à des données private, encapsulées
      • 11.2 Lire une variable private ou protected
      • 11.3 Modifier une variable private ou protected
      • 11.4 Lire et modifier une variable private ou protected
      • 11.5 Intérêt d'un appel de fonction
    • 12. L’instruction friend ("ami")
    • 13. Mise en pratique classe, objet
      • 13.1 Le pingouin
      • 13.2 Aspirateur drone
      • 13.3 Sous-marin nucléaire
      • 13.4 Ascenseur
  • Surcharge des opérateurs
    • 1. Introduction
    • 2. Fonction operator globale hors classe
    • 3. Fonction operator localisée dans une classe
      • 3.1 Operator+ sans retour
      • 3.2 Operator+ avec retour de l'objet courant (*this)
      • 3.3 Opérator+ avec retour d'un nouvel objet résultant
    • 4. Fonction operator et données dynamiques
      • 4.1 Surcharge operator+ dans la classe Tab
      • 4.2 Surcharge de l'opérateur d'affectation =
    • 5. Objet-fonction (ou fonction-objet)
  • Classes et membres static
    • 1. Introduction
    • 2. Qualificatif static en C
    • 3. Qualificatif static et objets
    • 4. Exemple : static pour une classe Console
      • 4.1 Utiliser le patron de conception "Singleton"
      • 4.2 Singleton pour une classe console
    • 5. Mise à jour de la bibliothèque outils.h
      • 5.1 Création du namespace OutilsCCP de outils.h
      • 5.2 Création du namespace OutilsC de outils.h
  • Classes génériques
    • 1. Introduction
    • 2. Principe
    • 3. Syntaxe de base
    • 4. Syntaxe des constructeurs
    • 5. Syntaxe avec plusieurs types génériques
    • 6. Paramétrage d’une classe générique
    • 7. Exemple d'implémentation d'une pile générique
    • 8. Spécialisation de fonction sur un type donné
    • 9. Spécialiser une classe entière
      • 9.1 Spécialisation partielle
      • 9.2 Spécialisation complète
  • Classe d'objets changeants
    • 1. Introduction
    • 2. Rappel union discriminée
    • 3. Principe de l'union illimitée : exemple météo mis à jour
  • Associations entre objets
    • 1. Introduction
    • 2. Questions
    • 3. Principes des associations pour les relations entre objets
      • 3.1 Association simple
      • 3.2 Agrégation
      • 3.3 Composition
      • 3.4 Problème syntaxique en C++
    • 4. Associations simples : messages entre objets
      • 4.1 Liaison non réciproque entre deux objets
      • 4.2 Liaison réciproque entre deux objets
    • 5. Agrégations : coopération entre objets
      • 5.1 Liaison à sens unique
        • 5.1.1 Cas général, syntaxe
        • 5.1.2 Guitariste et guitare
      • 5.2 Partage d'objets pointés
        • 5.2.1 Musiciens simultanés
        • 5.2.2 Plusieurs musiciens successifs
    • 6. Liaisons réciproques entre objets
      • 6.1 Problème de syntaxe
      • 6.2 Déclaration de type incomplet
      • 6.3 Limite du type incomplet
      • 6.4 Résolution du problème
      • 6.5 Piège d'une liaison réciproque
      • 6.6 Exemple Terminator
    • 7. Composition : dépendance entre objets
      • 7.1 De l'agrégation à la composition
      • 7.2 Techniques envisageables
      • 7.3 Pointeur d'objet en propriété
      • 7.4 Objet en propriété
      • 7.5 Référence d'objet en propriété
    • 8. Mise en pratique relations entre objets
      • 8.1 Récapitulation et rappels
      • 8.2 Associations simples
      • 8.3 Agrégations et compositions
  • Héritage
    • 1. Questions
    • 2. Principe
    • 3. Définir une classe dérivée
    • 4. Appeler explicitement un constructeur de la classe de base
    • 5. Redéfinition de données ou de fonctions
    • 6. Spécifier un membre de la classe de base
    • 7. Droits d'accès locaux de la classe héritée
    • 8. Droits d'accès globaux de la classe héritée
    • 9. Héritage multiple
      • 9.1 Principe et syntaxe
      • 9.2 Exemple : InDominusRex
      • 9.3 Relations transversales dans un arbre de classes
      • 9.4 Héritage multiple avec une base virtuelle
    • 10. Distinction entre héritage et association
    • 11. Mise en pratique héritage
      • 11.1 Comment identifier un héritage ?
      • 11.2 Les exercices
  • Polymorphisme et virtualité
    • 1. Questions
    • 2. Principe
    • 3. Accès pointeurs limité par son type
    • 4. Autorisation d'accès pour les fonctions virtuelles
    • 5. Destructeur virtuel
    • 6. Intérêt des fonctions virtuelles
    • 7. Exemple : virtualité dans la classe standard exception
  • Classe abstraite et interface
    • 1. Questions
    • 2. Classe abstraite, fonctions virtuelles pures
    • 3. Tronc commun pour dériver
    • 4. Interface
    • 5. Résumé classe abstraite et interface
    • 6. Expérimentation : exemples des super héros, les Avengers
      • 6.1 Classe de base super héros, interface des fonctions d'action
      • 6.2 Une dérivée pour chaque Avengers
      • 6.3 Souhait du polymorphisme et impossibilité
      • 6.4 Virtualité, intérêt de l'interface des fonctions d'action
      • 6.5 Classe abstraite
      • 6.6 Version finale Avengers
    • 7. Mise en pratique classe abstraite
  • Quelques comparaisons entre C et C++
    • 1. Introduction
    • 2. Sur les utilisations de pointeurs
      • 2.1 Définition
      • 2.2 Opérateurs de pointeurs
      • 2.3 Fonctionnement des opérateurs
      • 2.4 Utilisation 1 : en paramètre de fonction
      • 2.5 Utilisation 2 : mise en relation d’éléments
      • 2.6 Utilisation 3 : allocation dynamique
    • 3. Sur l'utilisation des paramètres et retours de fonctions
      • 3.1 Encapsulation des données C et C++
      • 3.2 Généralisation du code C et C++
      • 3.3 Paramètres et retours C++ : la communication entre objets
    • 4. Sur l'utilisation de l'union
      • 4.1 Principe d'une union hiérarchisée en C
      • 4.2 Traduction en C++ d'une union hiérarchisée
      • 4.3 Exemple : une diversité d'ennemis avec une union en C
      • 4.4 Traduction C++ avec une base et des dérivées
      • 4.5 Intérêt spécifique de l'union en C++
    • 5. Sur l'utilisation du typedef
    • Annexe : Priorité et associativité des opérateurs
    • Index

Auteur

Frédéric DROUILLONEn savoir plus

Frédéric DROUILLON est enseignant, chercheur et aussi créateur dans le domaine de l’informatique et des arts numériques. Il envisage la programmation et ses langages comme un moyen d’expression et de formulation d’idées qui nécessite de la recherche et de la créativité. L’objectif de son enseignement en langage C est de permettre au lecteur d’acquérir un savoir-faire fondamental en programmation informatique pour ensuite circuler le plus librement possible dans les différentes techniques et langages de programmation.

Caractéristiques

  • Niveau Initié à Confirmé
  • Nombre de pages 833 pages
  • Parution septembre 2018
    • Livre (broché) - 17 x 21 cm
    • ISBN : 978-2-409-01530-4
    • EAN : 9782409015304
    • Ref. ENI : RILCPP
  • Niveau Initié à Confirmé
  • Parution septembre 2018
    • HTML
    • ISBN : 978-2-409-01532-8
    • EAN : 9782409015328
    • Ref. ENI : LNRILCPP

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 (205 Ko)