IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)



Qu'est-ce que l'héritage ?
auteur : LFE
L'héritage consiste à construire une classe (appelée classe-fille) par spécialisation d'une autre classe (classe-mère).
On peut illustrer ce principe en prenant l'exemple des mammifères (classe-mère) et l'homme d'un coté (classe-fille 1) et les chiens (classe-fille2). En effet, les chiens et les hommes sont tous deux des mammifères mais ont des spécificités.


Qu'est-ce qu'un objet ?
auteur : Marshall Cline
Une zone de stockage avec une sémantique associée.

Après la déclaration suivante,

int i;
on peut dire que i est un objet de type int. En programmation objet / C++, "Objet" signifie habituellement "une instance d'une classe". Une classe définit donc le comportement d'un ou plusieurs objets (c'est-ce qu'on peut appeler "instance").


Qu'est-ce qu'une bonne interface ?
auteur : Marshall Cline
Quand elle présente une vue simplifiée d'un morceau de software, et est exprimée dans les termes de l'utilisateur (le morceau de software correspond habituellement à une classe ou un petit groupe de classes et l'utilisateur est un autre développeur, non le client final).

"Vue simplifiée" signifie que les détails sont intentionnellement cachés. Cela réduit donc le risque d'erreur lors de l'utilisation de la classe.

"Vocabulaire de l'utilisateur" veut dire que l'utilisateur n'a pas besoin d'apprendre de nouveaux mots ou concepts. Cela réduit donc la courbe d'apprentissage de l'utilisateur.


Qu'est-ce que l'encapsulation ?
auteur : Marshall Cline
Il s'agit d'éviter des accès non autorisés à certaines informations et/ou fonctionnalités.

L'idée clée est de séparer la partie volatile de la partie stable. L'encapsulation permet de dresser un mur autour d'une partie du code, ce qui permet d'empêcher une autre partie d'accéder à cette partie dite volatile ; les autres parties du code ne peuvent accéder qu'à la partie stable. Cela évite que le reste du code ne fonctionne plus correctement lorsque le code volatile est changé. Dans le cadre de la programmation objet, ces parties de code sont normalement une classe ou un petit groupe de classe.

Les "parties volatiles" sont les détails d'implémentation. Si le morceau de code est une seule classe, la partie volatile est habituellement encapsulée en utilisant les mots-clés private et protected. S'il s'agit d'un petit groupe de classe, l'encapsulation peut être utilisée pour interdire à des classes entières de ce groupe. L'héritage peut aussi être utilisé comme une forme d'encapsulation.

Les parties stables sont les interfaces. Une bonne interface procure une vue simplifiée exprimée dans le vocabulaire de l'utilisateur, et est créée dans l'optique du client. (un utilisateur, dans le cas présent, signifie un autre développeur, non pas le client qui achètera l'application). Si le morceau de code est une classe unique, l'interface est simplement l'ensemble de ses membres publiques et des fonctions amies. S'il s'agit d'un groupe de classes, l'interface peut inclure un certain nombre de classes.

Concevoir une interface propre et séparer cette interface de son implémentation permet aux utilisateurs de l'utiliser convenablement. Mais encapsuler (mettre dans une capsule) l'implémentation force l'utilisateur à utiliser l'interface.


L'encapsulation contitue-t-elle un mécanisme de sécurité ?
auteur : Marshall Cline
Non.

L'encapsulation ne constitue pas un mécanisme de sécurité. Il s'agit d'une protection contre les erreurs, pas contre l'espionnage.


Qu'est-ce "this" ?
auteur : LFE
this est un pointeur créé par défaut et qui désigne l'objet lui-même. A noter que this est un pointeur constant, c'est-à-dire qui ne peut pas être modifié, ce qui est d'ailleurs parfaitement logique.


Qu'est-ce que la surcharge ?
auteur : LFE
La surcharge est un mécanisme qui permet d'utiliser le même nom pour une fonction mais en lui passant des paramètres de types différents et/ou en nombre différent. Le nom de la fonction et les types des paramètres constituent ce qu'on appelle la signature de la fonction.

int moyenne(int i1, int i2); float moyenne(float f1, float f2); //surcharge valide float moyenne(int i1, int i2); //surcharge non valide

Qu'est-ce qu'un namespace ?
auteur : LFE
Un namespace, ou espace de nommage, est une zone de déclaration d'identificateurs permettant au compilateur de résoudre les conflits de noms.
Si, par exemple, 2 développeurs définissent des fonctions avec le même nom, il y aura un conflit lors de l'utilisation de ces fonctions dans un programme. Les espaces de nommage permettent de résoudre ce problème en ajoutant un niveau supplémentaire aux identificateurs.


Que signifie le mot-clé virtual ?
auteur : Anomaly
Le mot-clé virtual est utile pour redéfinir une fonction (présente dans une classe et réécrite avec exactement la même signature dans une classe dérivée).

Quand on appelle une méthode redéfinie, le compilateur utilise normalement le type statique (c'est-à-dire le type de la variable) pour savoir quelle méthode appeler.

Avec virtual, on demande d'utiliser le type dynamique, c'est-à-dire le type réel, connu à l'exécution seulement.

Dans quel cas y'a-t-il une différence ?
Dans le cas où on a un pointeur vers une classe de Base, et qui en fait pointe vers une classe dérivée.

class Base { public: void a() { cout << "Base::a" << endl; } virtual void b(); { cout << "Base::b" << endl; } }; class Derive : public Base { public: void a() { cout << "Derive::a" << endl; } virtual void b(); { cout << "Derive::b" << endl; } }; int main() { Base x; x.a(); // affiche Base::a x.b(); // affiche Base::b Derive y; y.a(); // affiche Derive::a y.b(); // affiche Derive::b // le cas intéressant Base * z = new Derive(); z->a(); // affiche Base::a z->b(); // affiche Derive::b }

Qu'est-ce qu'une référence ?
auteur : Marshall Cline
Une référence est un alias, un nom alternatif pour un objet.

Les références sont souvent utilisées lors du passage de paramètres par référence.

void swap(int& i, int& j) { int tmp = i; i = j; j = tmp; } int main() { int x, y; ... swap(x,y); ... }
Dans cet exemple, i et j sont des alias pour x et y du main. En d'autres mots, i est x (pas un pointeur sur x, ni une copie, mais x lui-même). Tout ce qui est fait à x est fait à i et inversement.

Bon, maintenant, pensons aux références du point de vue du programmeur. Au risque de provoquer la confusion en donnant une autre perspective voici comment les références sont implémentées. Au fond, une référence i vers un object x est habituellement son adresse. Mais quand le programmeur fait un i++, le compilateur génère du code qui incrémente x. Typiquement, les bits d'adressage que le compilateur utilise pour accéder à X sont inchangés. Un programmeur C pensera qu'il s'agit du passage d'un pointeur, avec les variantes syntaxiques suivantes :

  • Déplacer le & de l'appelant à l'appelé
  • Supprimer les notations *s

En d'autres mots, un programmeur le considérera comme une macro pour (*p), où p est un pointeur sur x (par ex., le compilateur déréférencerait automatiquement le pointeur : i++ serait transformé en (*p)++).

Note : même si une référence est souvent implémentée en utilisant une adresse dans le langage d'assemblage généré, ne considérez pas les références comme un pointeur "marrant" sur un objet. Une référence est l'objet. Ce n'est pas un pointeur sur l'objet, ni une copie de l'objet. C'EST l'objet.



Ce document issu de http://www.developpez.com est soumis à la licence GNU FDL traduit en français ici.
Permission vous est donnée de distribuer, modifier des copies de cette page tant que cette note apparaît clairement.
Certaines parties de ce document sont sous copyright Marshall Cline