Conception avancée de classes en C++

Name: Conception avancée de classes en C++
Author: Mikhail Veygman

Ce module est consacré à la conception des classes et à l'héritage. Nous introduirons les concepts d'une bonne conception de classe. Nous montrerons comment utiliser l'héritage pour décrire des objets du monde réel.

Preview the first lesson free — get full access to all 14 lessons.

Demander une démo Se connecter

Cours : à la demande

Avant de commencer à apprendre les nouvelles fonctionnalités avancées du C++, nous devons parler de certains des principes de conception de bonne classe. Pourquoi une bonne conception de classe est-elle importante ? C'est parce que sans une bonne conception de classe, la possibilité d'étendre les fonctionnalités du logiciel ou y ajouter de nouvelles fonctionnalités est sévèrement diminué. Parlons donc de certains des principes qui sont les plus utiles et commençons avec le principe appelé DRY. DRY est un acronyme qui signifie ne vous répétez pas, ce qui signifie que vous devez écrire du code pour faire quelque chose ou décrire quelque chose une et une seule fois. Alors qu'est-ce que cela signifie exactement? Jetons un coup d'oeil à un exemple. Vous avez une classe appelée DoNotRepeat, qui est mis en évidence. Et cette classe a des variables, certaines variables membres appelées integer_var, double_var et string_var. Il a également des fonctions pour définir ces variables et aussi récupérer leurs valeurs. Considérons maintenant l'autre classe, appelé cette classe Répétée. Jetez un œil à sa disposition très similaire. Il a des variables membres similaires appelées integer_var, double_var, string_var et a des fonctions d'interface similaires pour définir ces variables et récupérer certaines de leurs valeurs, mais aussi pour calculer une autre valeur sur la base de ces valeurs. Donc si vous regardez ces 2 classes et tu comprendras que si vous avez besoin de modifier une fonctionnalité, c'est pareil entre eux, vous devrez probablement apporter des modifications deux fois. Vous devrez changer le DoNotRepeat et vous devrez alors également modifier Répété, ce qui est bien sûr pratiquement possible, mais très mauvaise idée car changement de code qui doivent être répétés 2, 3, 4 fois est un très bon moyen d'introduire des bogues dans votre programme. Donc C++ vous fournit un mécanisme qui te permettra d'écrire le code qui est commun entre les 2 classes une et une seule fois, qui s'appelle l'héritage. Et nous en parlerons dans certaines des sections à suivre. Un autre principe dont nous avons besoin parler est d'encapsulation. Et ce principe est en fait très important. L'encapsulation est un principe selon lequel les propriétés de l'objet est protégé des accès directs par des fonctions ou des classes extérieures. Ce n'est pas la seule chose que l'encapsulation nécessite. Les objets correctement encapsulés ont une interface très étroite, ce qui signifie qu'un utilisateur extérieur ne peut faire que peu de choses avec les objets, mais le nombre de composants et fonctions internes à l'intérieur de l'objet peut être grand et ils pourraient faire certaines choses par eux-mêmes, mais vous ne pouvez pas exécuter ces fonctions sans accéder à l'interface de l'objet encapsulant. Pour cet exemple, examinons une classe d'objets appelée Mixer, qui décrit un mélangeur de cuisine sur pied. Dans mon exemple, Je décris un mixeur Kitchen Aid et comme vous pouvez le voir, il a une interface très simple. Vous pouvez le démarrer, l'arrêter, mélanger. Vous pouvez retirer la tasse, vous pouvez installer la tasse, vous pouvez déverrouiller le mélangeur, verrouiller le mélangeur, et vous pouvez également soulever le mélangeur. Ce sont les seules fonctions que vous pouvez effectuer sur l'objet correctement encapsulé. Vous savez aussi que le mélangeur contient des engrenages, moteur, contrôleur et quelques autres composants, mais vous n'y avez pas accès en tant qu'utilisateur normal de l'objet. Vous savez que ceux-ci existent individuellement. Ils ne vous intéressent que très peu et vous n'avez pas besoin de les contrôler ou avoir pour fonction de les contrôler sauf à travers l'objet. Le prochain principe que nous examinerons est appelé principe de responsabilité unique. C'est une façon élégante de dire cette classe devrait être responsable d'une chose et une seule chose. Si une classe, par exemple, est chargé de décrire une commande client, il ne devrait pas être responsable de la sauvegarde des informations de cette commande client à la base de données il ne devrait pas non plus être responsable de se convertir à un autre format comme XML. Pourquoi n'est-ce pas une bonne idée ? Eh bien, c'est en fait très simple. Lui-même à la base de données, par exemple, l'objet doit avoir les informations de la base de données. Donc, si vous avez de nombreuses commandes client, chacun doit avoir une copie des informations de la base de données, qui est sujet aux erreurs et rend le code vraiment déroutant à lire et très difficile à entretenir. Donc, à moins d'absolue nécessité, les dépendances comme celles-ci doivent être évitées. Le dernier principe dont nous parlerons dans cette section est appelé le principe ouvert-fermé. Le principe stipule que la classe doit être ouverte à l'extension, mais proche de la modification. Alors qu'est-ce que cela signifie exactement? Jetons un coup d'œil à quelque chose pour la validation des règles. Vous avez une classe appelée RuleValidation, qui a une méthode d'interface appelée règle de validation auquel vous mettez un objet règle, que vous pouvez décrire par vous-même. Et puis vous avez la logique de validation dans la méthode et cela signifie que chaque fois que vous ajoutez une nouvelle règle ou un nouveau type de validation, vous devrez changer la classe RuleValidation pour accueillir la nouvelle fonctionnalité. Une meilleure façon de le faire serait d'avoir une classe appelée ValidateRule, qui aura une fonction publique appelée valider. Donc pour chaque type de validation que vous souhaitez, vous allez créer un objet de cette classe. Et vous pouvez l'étendre à nouveau en utilisant l'héritage. Vous pouvez l'étendre pour, fournir un type spécifique de validation. Et puis vous pouvez réellement avoir une validation de règle, avoir un ensemble d'objets de règles de validation, qui valident nous appellerons en fait successivement jusqu'à ce qu'il sache que la règle est valide, ou il obtiendra l'échec sur chacun d'eux. De cette façon, l'objet de validation de règle ne doit pas beaucoup changer pour accueillir de nouvelles règles de validation. La seule chose dont vous aurez besoin ajouter est une fonction appelée addRuleValidator, qui prendra l'objet de règle de validation, et les ajoutera à l'ensemble de validation. Ajouter une règle de validation. Et puis vous pouvez très simplement ajouter de nombreuses validations autant de validations que vous le souhaitez, c'est exactement comme ça que c'est décrit dans le principe ouvert-fermé.

Avancé Fournisseur : Mikhail Veygman 14 leçons · 1h 14m en Arabe, Allemand, Anglais, Espagnol, Français, Portugais, Chinese

Description du cours

Ce module est consacré à la conception de classe et à l’héritage. Nous présenterons les concepts de bonne conception de classe. Nous montrerons la façon d’utiliser l’héritage pour décrire des objets du monde réel. Nous décrirons également les différents types d’héritage et comment les utiliser. Nous introduirons également un concept de composition qui peut être utilisé pour décrire les composants de l’objet réel.

Objectifs de la formation

Les compétences

Ce que vous allez apprendre

Appliquer les principes d'une bonne conception de classe (class design) en C++
Utiliser l'héritage pour modéliser des objets du monde réel, y compris l'héritage public, privé et protégé
Appliquer la composition de classes pour décrire les composants d'objets réels
Comparer la composition à l'héritage privé et les modèles (templates) à l'héritage
Gérer l'initialisation des classes et de leurs membres en utilisant les listes d'initialisation de membres et l'ordre d'initialisation correct
Utiliser l'encapsulation ainsi que les pointeurs et les références dans l'héritage

Points clés à retenir

Le module introduit les concepts d'une bonne conception de classe (class design) et les principes qui la sous-tendent.
L'héritage peut être utilisé pour décrire des objets du monde réel, et le cours aborde l'héritage public, privé et protégé.
La composition est présentée comme un moyen de décrire les composants d'un objet réel.
Le cours examine la comparaison entre la composition et l'héritage privé, ainsi que la comparaison entre les modèles (templates) et l'héritage.
Les sujets liés à l'initialisation des classes incluent les listes d'initialisation des membres et l'ordre d'initialisation.

Foire aux questions

Que couvre ce cours ?

Ce module couvre la conception de classes et l'héritage en C++, y compris les concepts d'une bonne conception de classes, l'utilisation de l'héritage pour décrire des objets du monde réel, les différents types d'héritage et la manière de les utiliser, ainsi que le concept de composition pour décrire les composants d'un objet de la vie réelle.

Quels types d'héritage sont enseignés ?

Le cours aborde l'héritage public, l'héritage privé et l'héritage protégé, et compare également la composition à l'héritage privé.

Quelles compétences vais-je acquérir grâce à ce cours ?

Le cours permet de développer des compétences en matière de concepts C++, de modules C++, de modélisation et conception orientées objet, de conception orientée objet, de définition intégrée pour la conception orientée objet (IDEF4 - Integrated Definition for Object-Oriented Design) et de présentation de fonctions avancées.

Quels sujets sur l'initialisation sont inclus ?

Les leçons abordent l'initialisation des classes, les listes d'initialisation des membres et l'ordre d'initialisation.