Discussion :

[ok07]

Bonsoir,
je suis en train d'apprendre le C++ et bloque sur une partie. En effet, je ne comprends pas l'interêt "des class", ni leur fonctionnement.
De même pour "les membres".

Je ne sais pas si j'ai posté dans la bonne catégorie, je m'en excuse.

Si vous pouviez m'aider... merci.

[koala01]

Salut,

Les classes sont utilisé pour faciliter ce que l'on appelle "la programmation orientée objet".

On peut dire, entre autre, que cela permet de disposer de l'encapsulation des données, d'une sécurisation de celles-ci, et d'un phénomène que l'on appelle "l'héritage".

Ce sont ces trois grandes caractéristiques qui font tout l'intéret des classes

Pour te donner une idée de ce qu'est l'héritage, on peut comparer les choses à une voiture:

Une voiture est un véhicule automoteur, et dispose, à ce titre de toutes les caractéristiques des autres véhicules automoteur, mais avec certaines "spécifications".

Une classe est, finalement, une structure de données, telle que l'on en rencontre en C avec les déclarations du genre de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
typedef struct mastruct
{
//les différents champs de la structure
};

en y rajoutant les routines (fonctions et procédures) qui permettent de travailler sur les "champs" de la structure.

Les champs prennent alors le nom générique de "membre", et les routines prennent le nom générique de "méthode".

Chaque classe créée représente un type utilisateur qui peut etre utilisable comme membre dans une classe plus spécialisée, tout comme toute structure peut servir de champs pour une structure plus précise.

Voici, sans entrer dans des détails trop indigestes, ce que l'on peut dire sur les classes et les membres, et qui devrait te permettre d'en comprendre un peu mieux l'utilisation.

[Bakura]

Bonsoir,
je suis en train d'apprendre le C++ et bloque sur une partie. En effet, je ne comprends pas l'interêt "des class", ni leur fonctionnement.
De même pour "les membres".

Je ne sais pas si j'ai posté dans la bonne catégorie, je m'en excuse.

Si vous pouviez m'aider... merci.

Un exemple que j'ai vu dans mes bouquins de C++. Par exemple tu peux créer une classe Animal. Un animal, quelque soit son type (que ce soit un éléphant, un chat, un chien, un perroquet), a par exemple un âge, un prénom, une couleur, une couleur des yeux... Ainsi tu pourras déclarer une instance de cette classe, par exemple Animal animal1 (16, "titi")... Cet animal à 16 ans et s'appelle titi... De cette classe de base tu pourras en faire hériter d'autres classes dérivés, par exemple une classe Chien, et une classe Chat,... qui auront chacun des caractéristiques spéciales en plus. Chaque Chat ou Chien EST UN animal, a donc un prénom, un age, une couleur, mais on en plus d'autres caractéristiques. Un chien a par exemple une race spécifique,...

Ca permet de simplifier un peu tout ^^.

[bengign]

Si je ne m'abuse, en plus des capacités techniques décrite plus haut, l'un des buts d'un programme orienté objet est de faire interagire entre eux des objets, afin de réaliser un programme d'une façon plus "proche " du monde réel. Les classes permettent de créer ces objets.

[Luc Hermitte]

Une classe, c'est le type d'un objet -- en C++ et divers autres langages.
Et en résumant un peu violemment, un objet c'est des propriétés et des comportements réunis ensembles -- je sais, c'est mal dit -- plus un état encapsulé (comme on dit) dont l'implémentation relève du détail d'implémentation.

En C++, "membre" est le terme générique qui désigne les fonctions (qui définissent comportements, rôles, messages, ...) et les variables (attributs dans ce cas) qui composent les objets.

Pour garder les exemples sur les animaux, une fourmi peut se deplacer (comme les autres animaux), se nourrir, poser des phéromones... Elle a des propriétés qui peuvent être consultées : son âge, son nombre de pattes. Et elle a un état interne (elle doit bien avoir un réseau neuronal simpliste), une date de naissance inaltérable, ...
Et bien les objets fourmi seront des instances de la classe Fourmi.
Les verbes seront des fonctions membre.
Les propriétés en lecture seule des accesseurs (fonction membre particulière), éventuellement associées à des données membres
L'état interne étant défini à partir de données membres (privées) qui relèvent du détail d'implémentation.

Typiquement (Il aurait probablement fallu séparer Animal en IAnimal et AminalImpl)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
struct Animal {
    // constructeur par défaut 
   Animal(std::auto_ptr<DecisionCenter> dc) : birthdate_(now()), dc_(dc) {}
   // destructeur
   virtual ~Animal() {}
 
   // comportements, ...
   virtual void moveTo( Position const& ) = 0;
   virtual void feed( Eatable & ) = 0;
 
   Action decideNext() const {
       return dc_ -> decideNext();
   }
 
   // propriété associée à une donnée membre
   Delay getAge() const { return now() - birthDate_; };
   // propriété NON associée à une donnée membre, mais au type d'animal
   virtual unsigned short getLegs() const = 0;
 
 
protected:
   // propriété à usage interne, associée à une donnée membre
   Position const& getPosition() const { return pos_; }
   void setPosition( Position const& pos ) {
        if (WORLD::instance() . CanGoTo( *this, pos ))
           pos_ = pos;
   }
 
private:
   // détail d'implémentation utilisé pour déterminer l'âge ; c'est une donnée membre
   Date birthdate_;
   // Autre détail : un animal est quelque part dans le monde
   Position pos_;
 
   // L'intelligence (IA ou déportée) : un détail d'implémentation propre 
   // à chaque espèce, à un éventuel joueur, à des sortilèges dans le 
   // cas de RPGs
   boost::scoped_ptr<DecisionCenter> dc_;
};
 
struct Insect  : Animal {
   Insect(std::auto_ptr<DecisionCenter> dc) : Animal(dc) {}
 
   // spécialisation d'un accesseur dans le cas des insectes
   virtual unsigned short getLegs() const { return 6; }
};
 
struct Ant : Insect {
   // Le constructeur
   Ant( Params ... ) : Insect(new DC_AntAI(this)), leftAntenna(..), ... {} 
 
   // spécialisations :
   // les implémentations qui vont bien pour feed, moveTo, ... 
   // sachant que c'est une fourmi qui se déplace ou qui mange
   virtual void moveTo( Position const& ) { ... détails } 
   virtual void feed( etable & )  { ... détails } 
 
   // nouveaux comportements propres aux fourmis
   void leaveMessage(Pheronom const& ) { ... détails }
private:
   // Les capteurs propres aux fourmis ; et probablement à d'autres insectes en fait
   Antenna leftAntenna_;
   Antenna rightAntenna_;
};

Je suis encore parti sur un truc compliqué (les animaux sont un exemple récurrent pourtant difficile à modéliser proprement -- je préfère vraiment les petites chaînes automatisées), qui ne compile évidemment pas. Ceci dit, si tu décortiques, tu verras plusieurs des élements propres à la modélisation OO.

[ok07]

Merci pour vos réponses. Je souhaiterez, si vous le voulez bien, avoir quelques précisions sur les constructreurs & les destructeurs : leur intérêt, etc

Je vous remercie.

[Jean-Marc.Bourguet]

Merci pour vos réponses. Je souhaiterez, si vous le voulez bien, avoir quelques précisions sur les constructreurs & les destructeurs : leur intérêt, etc

Je vous remercie.

Un constructeur est une routine utilisée pour initialiser un objet. Son intérêt est que, comme un objet ne peut pas exister sans qu'un des constructeurs de sa classe ait été appelé, il peut s'assurer que les valeurs des différents membres sont cohérentes.

Un destructeur (il n'y en a qu'un par classe, au contraire des constructeurs) est une routine qui est appelée juste avant que l'objet cesse d'exister. Son intérêt est que quelle que soit la manière dont l'objet cesse d'exister, son constructeur sera appelé. On s'en sert pour faire des choses comme libérer de la mémoire et des ressources (une technique courante en C++ est même de faire des objets rien que pour leur destructeur, comme ça on est sûr que quelle que soit la manière dont on quitte un bloc, quelque chose sera fait).

[loufoque]

Le constructeur te permet de définir comment on initialise un objet.
Le destructeur te permet de libérer les ressources utilisées par ton objet, ou aussi pour faire n'importe quoi qui doit être fait au moment de sa destruction.

Par exemple std::list<T> doit appeler les destructeurs de tous les objets qu'il contient lors de sa destruction puis rendre la mémoire au système (ou plus précisemment à l'allocateur qui va pouvoir éventuellement la réutiliser)