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)

[ok07]

Merci encore pour vos réponses.

[koala01]

Une petite précision quant à la réponse de loufoque, cependant...

Le programmeur n'appellerea jamais lui-même le destructeur d'une classe.

Il sera appelé, lorsque l'instance de la classe aura été créée dynamiquement, automatiquement par l'operateur delete ou delete[], et, lorsqu'il s'agit d'une instance créée statiquement ( Maclasse objet(); ), lorsque la routine dans laquelle l'instance est déclarée est quittée, au meme titre que n'importe quelle variable.

[Jean-Marc.Bourguet]

Le programmeur n'appellerea jamais lui-même le destructeur d'une classe.

Si, ça se fait mais c'est rare et c'est encore plus rare que ce soit la bonne solution. On le fait quand il faut découpler la gestion de la mémoire de la durée de vie des objets, un bon exemple: c'est ce qui permet d'avoir une différentre entre la capacity() et la size() d'un std::vector.

Un exemple à ne pas suivre, c'est l'anti-idiome

Code :

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

1
2
3
4
T* operator=(T const& other) {
   this->~T();
   new (this)T(other);
}

pour éviter de dupliquer du code entre operator= et le constructeur de copie. (Le problème le plus visible a lieu quand le constructeur de copie jette une exception, on se retrouve avec un objet déjà détruit mais qui le sera une deuxième fois).

[koala01]

Le programmeur n'appellerea jamais lui-même le destructeur d'une classe.

Si, ça se fait mais c'est rare et c'est encore plus rare que ce soit la bonne solution. On le fait quand il faut découpler la gestion de la mémoire de la durée de vie des objets, un bon exemple: c'est ce qui permet d'avoir une différentre entre la capacity() et la size() d'un std::vector.

Ou, de fait, dans les cas particuliers de singleton, avec leur méthode FreeInstance(), ou dans les cas, encore plus particuliers, de la surcharge (très rare) des opérateur new (ou new[]) et delete(ou delete[])

De fait, le terme jamais était très imparfait dans ce cas...

Mais, quelque part, mieux vaut que ok07 parte du principe que le code

Code :

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

1
2
3
4
5
6
7
 
main
{
    MaClasse *monobjet=new Maclasse;
//travail sur monobjet;
    monobjet->~Maclasse();
}

risque très clairement de lui poser quelques soucis, et que l'acces direct au destructeur ne doit etre envisagé que quand on sait très clairement ce qu'on fait

[NewbiZ]

dans les cas, encore plus particuliers, de la surcharge (très rare) des opérateur new (ou new[]) et delete(ou delete[])

Je plussoie, l'appel explicite du destructeur et assez fréquent lorsqu'on développe des mécanismes tel que le placement new, dans une optique d'éviter la fragmentation de la mémoire allouée dynamiquement.

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
 
// Mémoire brute pour stoquer nos instances
Foo *foo = reinterpret_cast<Foo *>(::operator new(nbElem*sizeof(Foo)));
 
// Création de chaque instance
for (int index = 0; index < nbElem; ++index)
{
  new (foo + index) Foo(index);
}
 
// Destruction de chaque instance
for (int index = 0; index < nbElem; ++index)
{
  foo[index].~Foo();
}
 
// Destruction de la mémoire
::operator delete(foo);

[loufoque]

Oui enfin ce n'est pas très élégant comme code, ni exception-safe.
Je n'utilise personnellement jamais le placement new de cette façon pour ces raisons.

[NewbiZ]

Code :

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

Oui enfin ce n'est pas très élégant comme code, ni exception-safe.

Ce n'est effectivement pas très élégant, ni même facilement maintenable, mais il y a des fois où il faut sacrifier l'élégance à la rapidité

[koala01]

Je plussoie, l'appel explicite du destructeur et assez fréquent lorsqu'on développe des mécanismes tel que le placement new, dans une optique d'éviter la fragmentation de la mémoire allouée dynamiquement.
(...)

Heuu, il s'agit peut etre de rencenter ici le débat, qui risque de passer à 100 lieues au dessus de la tete de notre pauvre 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".

AMHA, il est encore loin du problème de la framentation de la mémoire ...

Va d'ailleurs savoir s'il est au courent que l'opérateur new effectue 3 actions (enfin, si, maintenant, il le saura )

Dans quelle mesure, certaines des dernières interventions (dont mes deux dernières) ne deviennent-elles pas clairement hors sujet, vu qu'on s'adresse quand meme à un débutant (ce n'est pas péjoratif: tout le monde l'a été )???

[loufoque]

Code :

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

1
2
3
4
std::vector<Foo> foo;
foo.reserve(nbElem);
for(int index = 0; index < nbElem; ++index)
    foo.push_back(Foo(index));

n'est pas beaucoup plus coûteux et est tellement plus propre et plus pratique.

[NewbiZ]

Code :

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

1
2
3
4
std::vector<Foo> foo;
foo.reserve(nbElem);
for(int index = 0; index < nbElem; ++index)
    foo.push_back(Foo(index));

n'est pas beaucoup plus coûteux et est tellement plus propre et plus pratique.

Pas beaucoup plus couteux certes (quoique ca se discute, lorsque les manipulations interviennent ...), mais tu perds beaucoup d'avantages du placement new, tu n'a pas la possibilité par exemple de distinguer l'allocation et l'appel du constructeur, tu perds aussi la possibilité d'un default ellipsing, de stoquer des données en (this+1) etc...
Enfin, comme l'a dit koala01, peut être est-il temps d'arrêter cette joyeuse masturbation intellectuelle, pour revenir dans le vif du sujet