IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Sommaire > Les classes en C++
        Qu'est-ce qu'une classe ?
        Comment puis-je empêcher les autres programmeurs de violer l'encapsulation en accédant aux membres privés de mes classes ?
        Comment dériver une classe à partir d'une autre ?
        Qu'est-ce qu'une classe abstraite ?
        Qu'est-ce qu'une fonction virtuelle pure ?
        Que signifient public, private et protected ?
        Comment créer 2 classes qui font référence l'une à l'autre ?
        Que signifie la déclaration suivante : "statit const int MAX=10" ?
        Comment définir l'implémentation d'une classe en l'ayant définie comme faisant partie d'un namespace ?
        Pourquoi déclarer un membre static dans une classe ?
        Quelle est la particularité d'une méthode static ?
        Comment initialiser un membre static ?
        A quoi cela sert-il d'utiliser des accesseurs ?
        5.1. Les constructeurs(17)
                Qu'est-ce qu'un constructeur ?
                Y a-t-il une différence quelconque entre List x; et list x(); ?
                Un constructeur d'une classe peut-il appeler un autre constructeur de la même classe pour initialiser 'this' ?
                Est-ce que le constructeur par défaut pour Fred est toujours Fred::Fred() ?
                Quel constructeur est appelé quand je crée un tableau d'objets Fred ?
                Mes constructeurs doivent-ils utiliser les listes d'initialisation ou l'affectation ?
                Puis-je utiliser le pointeur this dans un constructeur ?
                Qu'est-ce que l'idiome du constructeur nommé (Named Constructor)?
                Pourquoi ne puis-je pas initialiser un membre statique dans la liste d’initialisation ?
                Pourquoi les classes avec des membres statiques me donnent-elles des erreurs lors de l'édition des liens ?
                Qu'est-ce que le "fiasco dans l'ordre d'initialisation des variables statiques" ?
                Comment puis-je éviter le "fiasco dans l'ordre d'initialisation des variables statiques" ?
                Pourquoi l'idiome de construction à la première utilisation utilise-t-il un pointeur statique plutôt qu'un object statique ?
                Comment puis-je éviter le "fiasco dans l'ordre d'initialisation des variables statiques" pour les données membres statiques ?
                Dois-je me préocuper du "fiasco dans l'ordre d'initialisation des variables statiques" pour les types de base ?
                Que faire en cas d'échec du constructeur ?
                Qu'est ce que "l'idiome des paramètres nommés" ?
        5.2. Les destructeurs(11)
                Qu'est-ce qu'un destructeur ?
                Puis-je surcharger un destructeur ?
                Est-il possible d'invoquer explicitement le destructeur d'une classe ?
                Dans quel ordre les objets locaux sont-ils détruits?
                Dans quel ordre les objets contenus dans un tableau sont-ils détruits?
                Doit-on détruire explicitement les objets locaux ?
                Et si on veut absolument qu'un objet local "meure" avant l'accolade fermant le bloc dans lequel il a été créé?
                Et s'il n'est pas possible de placer l'objet local dans une bloc artificiel?
                Peut-on détruire explicitement un objet alloué par new ?
                Dans le code d'un destructeur, doit-on détruire explicitement les objets membres?
                Dans le code du destructeur d'une classe dérivée, doit-on appeler explicitement le destructeur de la classe de base ?
        5.3. Les amis (friend)(5)
                Que signifie 'friend' ?
                Les amis brisent-ils l'encapsulation ?
                Quels avantages/désavantages y-a-t-il à utiliser des fonctions friend ?
                Que signifie "l'amitié n'est ni héritée ni transitive, ni réciproque" ?
                



Qu'est-ce qu'une classe ?
auteur : LFE
D'une façon très simple et en faisant le parallèle avec le C, on peut dire qu'une classe est une structure à laquelle on ajoute des fonctions permettant de gérer cette structure.
Mais outre l'ajout de ces fonctions, il existe deux grandes nouveautés par rapport aux structures du C,

  • d'une part, les membres de classe, qu'ils soient des propriétés ou des fonctions, peuvent être privés c'est-à-dire inaccessibles de l'extérieur (alors que tous les éléments d'une structure du C étaient accessibles)
  • d'autre part, une classe peut être dérivée. La classe dérivée hérite alors de toutes les propriétés et fonctions de la classe mère. Une classe peut d'ailleurs hériter de plusieurs classes simultanément.

Une classe se déclare par la directive class, les membres de la classe, propriétés ou fonctions, se situent à l'intérieur de parenthèses et la déclaration de termine par un point virgule juste après la parenthèse fermante.

class MaClasse { // ... déclaration de tous les membres, propriétés ou fonctions, constitutives de la classe // ... };

Comment puis-je empêcher les autres programmeurs de violer l'encapsulation en accédant aux membres privés de mes classes ?
auteur : Marshall Cline
Le jeu n'en vaut pas la chandelle, l'encapsulation est faite pour le code, pas pour les gens.

Ce n'est pas violer l'encapsulation pour un programmeur que de voir les parties privées et/ou protégées de vos classes, tant qu'il n'écrit pas de code qui dépende d'une façon ou d'une autre de ce qu'il voit. En d'autres termes, l'encapsulation n'empêche pas les gens de découvrir comment est constituée une classe; cela empêche que le code que l'on écrit ne soit dépendant de l'intérieur de la classe. La société qui vous emploie ne doit pas payer un "contrat de maintenance" pour entretenir la matière grise qui se trouve entre vos 2 oreilles, mais elle doit payer pour entretenir le code qui sort de vos doigts. Ce que vous savez en tant que personne n'augmente pas le coût de maintenance, partant du principe que le code que vous écrivez dépend de l'interface plus que de l'implémentation.

D'un autre coté, ce n'est rarement, voire jamais un problème. Je ne connais aucun programmeur qui ait intentionnellement essayé d'accéder aux parties privées d'un classe. "Mon avis dans un tel cas de figure serait de changer le programmeur et non le code" (James Kanze, avec son autorisation)


Comment dériver une classe à partir d'une autre ?
auteur : LFE
Pour dériver une classe à partir d'une autre, il suffit de faire suivre la déclaration de la classe dérivée de : suivi d'un modificateur d'accès et du nom de la classe mère.

class mere { // ... } class fille : public mere { // ... }
L'héritage peut être public, private, ou protected.
Si l'héritage est public, les membres de la classe mère garderont leur accès, à savoir les membres public restent public et les protected restent protected.
Si l'héritage est protected, les membres public de la classe mère deviendront protected dans la classe fille, et les protected resteront protected.
Si l'héritage est private, tous les membres de la classe mère, qu'ils aient été public ou protected deviennent private.
Les membres private de la classe mère sont inaccessibles depuis la classe fille, quelque soit le type d'héritage.


Qu'est-ce qu'une classe abstraite ?
auteur : LFE
Une classe abstraite est une classe qui possède au moins une fonction vituelle pure. Ce type de classe ne peut pas être instanciée. Elle doit obligatoirement être dérivée et la ou les fonctions virtuelles pures doivent être redéfinies obligatoirement dans la classe fille.

lien : Qu'est-ce qu'une fonction virtuelle pure ?

Qu'est-ce qu'une fonction virtuelle pure ?
auteur : LFE
Une fonction virtuelle pure est une fonction qui est déclarée mais qui n'a pas d'implémentation dans la classe où elle est définie. Elle transforme cette classe en une classe abstraite.
Elle se déclare de la façon suivante :

class MaClasse { // ... virtual void maFctVirtuelle() const = 0; // = 0 signifie "virtuelle pure" // ... };

Que signifient public, private et protected ?
auteur : LFE
Un membre déclaré private dans une classe ne peut être accédé que par les autres membres de cette même classe.

Un membre déclaré protected dans une classe ne peut être accédé que par les autres membres de cette même classe ainsi que par les membres des classes dérivées.

Un membre déclaré public dans une classe peut être accédé par toutes les autres classes et fonctions.


Comment créer 2 classes qui font référence l'une à l'autre ?
auteur : pipin
Il arrive souvent qu'une classe1 contienne un attribut (ou un argument de fonction) de type classe2 et que la classe2 contienne un attribut (ou un argument de fonction) de type classe1.

Dans ce cas, il faut faire une déclaration anticipée de la classe2.

// classe1.h #ifndef _CLASSE1_H_ #define _CLASSE1_H_ class classe2; // déclaration anticipée de classe2 class classe1 { //.... classe2 m_Classe2; //.... }; #endif // _CLASSE1_H_ // classe2.h #ifndef _CLASSE2_H_ #define _CLASSE2_H_ class classe1; // déclaration anticipée de classe1 class classe2 { //.... classe1 m_RefToClasse1; // .... }; #endif // _CLASSE2_H_

Que signifie la déclaration suivante : "statit const int MAX=10" ?
auteur : Musaran
const signale que la variable ne peut pas changer de valeur, et que le compilateur refusera qu'on le fasse.

static (dans le cas de la classe) signifie que la variable n'existe qu'en un seul exemplaire, elle est globale à la classe en quelque sorte. Autrement, chaque objet du type de la classe dispose de sa propre copie.


Comment définir l'implémentation d'une classe en l'ayant définie comme faisant partie d'un namespace ?
auteur : LFE
namespace myNS { maClasse::maFonction() { // .... } maClasse::monAutreFonction() { // .... } }

Pourquoi déclarer un membre static dans une classe ?
auteur : LFE
Déclarer un membre static dans une classe permet de n'avoir qu'une instance de ce membre en mémoire. Toute modification effectuée sur ce membre dans une instance de cette classe sera visible par les autres instances.
On peut voir cela comme une façon de mettre en place un mécanisme de 'variables globales' internes à la classe, par exemple.


Quelle est la particularité d'une méthode static ?
auteur : LFE
Une méthode static a la particularité de pouvoir être appelée sans devoir instancier la classe.
Elle ne peut utiliser que des membres et des méthodes static, c'est-à-dire qui ont une existence en dehors de toute instance.

// appel d'une méthode static Instance.methode(); // ou Class::methode();

Comment initialiser un membre static ?
auteur : LFE
Le membre static doit être initialisé dans le fichier .cpp de la façon suivante.

// dans le fichier .h #ifndef __LASER_H #define __LASER_H class laser { public: static int compteur; laser() { } ~laser(){} }; #endif // dans le fichier .cpp #include "laser.h" int laser::compteur=0;

A quoi cela sert-il d'utiliser des accesseurs ?
auteur : LFE
L'utilisation de méthodes Get/Set permet de masquer l'implémentation des données de la classe et de faire évoluer celle-ci sans contrainte pour l'utilisateur final.
Cela permet en quelque sorte de séparer l'utilisation des données de leur implémentation.
Cela permet aussi d'effectuer des traitements ou des contôles annexes lors de l'assignation des membres.



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