Discussion :

[ZeGuizmo]

Salut à tous,

Je sèche sur un problème totalement stupide, qui démontre bien mon ignorance de ce langage pointu qu'est le C/C++

Lorsque je déclare une variable membre d'un certain type, que je l'assigne, comment puis-je revenir à l'état initial de cette variable, et tout d'abord, que contient-elle ?

Un exemple pour que cela soit plus concret

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
class Message 
{
    void Message() {};
    void init() {m_text = "blah"};
    std::string getText() {return m_text};    
 
    private :
    std::string m_text;
}
 
class User
{
    void User();
    void checkMsg() {m_Message.init()};
 
    private :
    Message m_Message;
}

Vous l'aurez compris, cet exemple est bidon, c'est pour illustrer ce que je souhaite faire.

Si j'instancie un nouvel utilisateur, je ne sais pas bien ce que vaut la variable m_Message, de même, après avoir appelé la fonction checkMsg, je ne sais pas réinitialiser la variable m_Message à son état initial, c'est à dire retourner dans l'état où m_text ne vaut pas "blah" (d'ailleurs, il vaut quoi quand la méthode init n'a pas été appelée ?)

Merci de votre aide,

Guiz

[koala01]

Salut,

Le propre du paradigme orienté objet et de ne plus réfléchir en terme de données mises ensemble pour représenter une donnée plus complexe, mais bien de réfléchir en termes de services que l'on attend de l'objet.

Un service attendu peut être, selon le cas, la réponse à une question que l'on pose, la réaction adaptée à un message qu'on lui transmet ou, pourquoi pas, l'émission d'un message vers un objet connu de l'objet auquel on s'adresse.

Par exemple, en programmation séquentielle pure, une voiture serait vue sous l'angle de l'ensemble des objets moins "complexes" qui la composent: la carrosserie, le moteur, quatre roues, un volant, un réservoir d'essence, plusieurs sièges ou banquettes etc alors que, d'un point de vue OO, on s'intéressera au fait qu'elle peut démarrer, ralentir, tourner, nous répondre à des questions comme "quel est l'état de remplissage du réservoir" ou "de combien de places dispose-t-on" mais que ce dont la voiture est composé est finalement secondaire...

Parmi les services qu'un objet peut rendre, il y a deux types particuliers qui peuvent agir directement sur une donnée membre: les accesseurs et les mutateurs ( "getter" et "setter", en anglais)

Le rôle d'un accesseur est, simplement, de permettre à l'utilisateur de disposer... de l'information demandée (comme c'est le cas de ta fonction "getText") mais... en lecture seule.

Celui d'un mutateur est, tout aussi simplement, de permettre à l'utilisateur de modifier une information particulière, mais, en toute logique, uniquement sur... des objets non constants.

On passe, pour ce faire, par la transmission au mutateur d'un argument du type concerné.

Quelque part, ta fonction "init" est fort proche de ce que pourrait être un mutateur, même si elle pourrait être adaptée et renommée.

En effet, le service que tu attend de init n'est pas... d'initialiser ton objet...:

Il existe en effet un principe nommé RAII (Ressource Acquisition Is Initialization, ou, si tu préfère la langue de voltaire, L'acquisition des ressources sert d'initialisation) qui conseille de veiller à ce que l'objet soit utilisable dés qu'il est construit...

L'initialisation devrait donc survenir... dans le constructeur.

Par contre, le service que tu attend de init serait, de manière beaucoup plus générale de... pouvoir modifier la valeur du membre m_text...

L'idée est donc de placer un mutateur sur m_text, que l'on pourrait nommer "setText" et auquel nous passerions... un paramètre de type std::string correspondant...

De cette manière, lorsque tu veux modifier le texte, que ce soit pour le "réinitialiser" ou, simplement pour le changer, tu n'aura plus qu'à... appeler cette fonction setText.

Elle pourrait prendre la forme de

Code :

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

1
2
3
4
5
6
class Message
{
    public:
       void setText(std::string const & m){m_text = m;}
       /* le reste de la classe */
};

Je voudrais par contre revenir sur ton accesseur "getText", car je me dois de réagir dessus:

Il est généralement conseillé d'éviter les copies d'objet autant que faire se peut...

En effet, lorsqu'il y a copie, il y a, "en toile de fond", tout un mécanisme qui peut être lent et couteux en terme de mémoire qui est mis en œuvre.

C'est pourquoi, il est conseillé chaque fois que faire se peut de passer ou de renvoyer tes différents objets sous la forme de référence.

En effet, la référence agit strictement comme un alias de l'objet transmis / renvoyé, ce qui évite la copie.

Par contre, il faut prendre la précaution d'empêcher que l'objet ne soit modifié (au travers de son alias) s'il ne doit pas l'être.

il serait en effet dommage (et potentiellement dangereux) de permettre un

Code :

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

1
2
Message msg;
msg.getText()="salut";

qui aurait pour résultat... de modifier notre message msg...

Dans ce cas, il faut donc transmettre /renvoyer cet objet sous forme d' une référence constante.

L'avantage direct que nous en tirerons sera de pouvoir faire en sorte que getMessage s'engage à ne pas modifier l'objet au départ duquel elle est invoquée en la déclarant constante sous la forme de

Code :

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

1
2
3
4
5
6
7
8
9
class Message
{
    public:
        std::string const & /* (1 ) */ getMessage() const /* ( 2 ) */
        {
            return m_text;
        }
        /* ... */
};

(NOTA : Le const en (1) indique que la chaine renvoyé ne peut pas être modifiée et le const en (2) indique que getText s'engage à ne pas modifier l'objet courent)
Nous pourrions donc envisager une fonction proche de

Code :

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

1
2
3
4
5
6
7
void doSomething(Message const & m) /* m n'a pas vocation à être 
                                     * modifié 
                                     */
{
    m.getText(); // OK
    m.setText("bonjour"); // KO... on a dit que m ne peut pas etre modifié...
}

Enfin, je ne peux parler des accesseurs et mutateurs sans me fendre d'un conseil important:

S'ils sont nécessaires, voire, indispensables dans certains cas, il faut les utiliser avec prudence car de nombreuses variables membres n'en on purement et simplement pas besoin:

Il ne sert à rien de placer un accesseur, ou pire, un mutateur, sur une variable qui n'est utilisée que de manière strictement interne à l'objet en cours

PS: C/C++ n'existe pas et est sans doute *le* terme honnis par excellence...

En effet, même si C++ hérite de C, ce terme entretient la confusion sur le fait qu'il s'agit de deux langages totalement différents, avec, dans le meilleur des cas, la tentation d'utiliser (ce qui est fortement déconseillé) en C++ des méthodes propres à C et, dans le pire des cas d'utiliser en C des méthodes propres à C++ (ce qui est interdit)...

[ZeGuizmo]

Merci à toi koala01 pour cette précision très instructive sur la façon d'accéder aux variables membres d'une classe.

Bien que je trouve pléthores de bon conseils dans la grande réponse que tu m'as faite, je ne trouve pas la réponse à ma question initiale, qui n'était pas de savoir comment mettre une variable membre à un état, mais qui était de savoir ce que valait une variable membre de type objet avant son attribution.

En gros, quand on fait

std::string text;

Que vaut text ? NULL ?

Et une fois qu'on a fait

text = "blah";

Comment le remettre dans sa valeur initiale ? (text = NULL; ?)

J'ai essayé avec le NULL, ça ne semble pas fonctionner, donc c'est pour cela que je m'interroge.

Merci,

Guiz

[koala01]

Que vaut text ? NULL ?

Surement pas... NULL est une valeur dédiée à la gestion des pointeurs...

text n'est pas un pointeur

La classe std::string respecte le RAII et dispose d'un constructeur par défaut (ne prenant aucun argument) qui initialise la chaine sous la forme... d'une chaine vide (équivalent à "")...

C'est ce constructeur de std::string qui est appelé automatiquement par le constructeur de ta classe Message lorsque tu en crées une instance

Et une fois qu'on a fait

text = "blah";

Comment le remettre dans sa valeur initiale ? (text = NULL; ?)

Tu auras compris que ce n'est pas NULL qu'il faut lui donner comme valeur, mais ... ""

J'ai essayé avec le NULL, ça ne semble pas fonctionner, donc c'est pour cela que je m'interroge.

Et pour cause...

Mais les explications et la réponses viennent d'être données

[Davidbrcz]

Il faut cependant comprendre que ta chaîne de caractère possède la valeur "" par défaut car son constructeur par défaut lui donne cette valeur. Mais dans le cadre de type natif (int, double, ...) les valeurs sont indéterminés.
Exemple

Code :

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

1
2
3
4
5
6
7
8
9
10
11
struct foo
{
int i;
};
 
int main()
{
foo f;
std::cout<<f.i<<std::endl; //peut afficher n'importe quoi (chez moi 1069653584)
return 0;
}

[ZeGuizmo]

Merci pour vos deux réponses, elles apportent toutes deux des réponses à la question que je me pose.

J'allais justement réagir sur les types natifs

Si j'ai bien compris, pour résumer, les types natifs prennent des valeurs de leur type mais indeterminées, donc il n'y a pas lieu d'effectuer une réinitialisation. Et pour les objets bénéficiant d'un constructeur, le simple fait de faire

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
class foo 
{
    foo() {};
}
 
class bar 
{
    bar() {};
    private :
    foo privateFoo;
}
 
int main()
{
    bar b;
}

Va appeler les constructeurs par défaut de bar et de foo, donc ici, pour réinitialiser la variable b si je la modifie, je dois explicitement appeler le destructeur et la ré-instancier en faisant un truc du genre : b = new bar(); ?
Et le destructeur de bar, dois-je le déclarer explicitement pour que lui aussi, il appelle le destructeur de foo ?

Merci de votre patience

Guiz

[JolyLoic]

Si j'ai bien compris, pour résumer, les types natifs prennent des valeurs de leur type mais indeterminées

Pas tout à fait. Lire la valeur d'un objet d'un type de base non initialisé est un comportement indéterminé. Ça peut donner une valeur spécifique, une valeur au hasard, faire planter le programme, rebooter la machine, ou tout autre comportement que souhaite mettre en place le compilateur.

[Goten]

Merci pour vos deux réponses, elles apportent toutes deux des réponses à la question que je me pose.

J'allais justement réagir sur les types natifs

Si j'ai bien compris, pour résumer, les types natifs prennent des valeurs de leur type mais indeterminées, donc il n'y a pas lieu d'effectuer une réinitialisation. Et pour les objets bénéficiant d'un constructeur, le simple fait de faire

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
class foo 
{
    foo() {};
}
 
class bar 
{
    bar() {};
    private :
    foo privateFoo;
}
 
int main()
{
    bar b;
}

Va appeler les constructeurs par défaut de bar et de foo, donc ici, pour réinitialiser la variable b si je la modifie, je dois explicitement appeler le destructeur et la ré-instancier en faisant un truc du genre : b = new bar(); ?
Et le destructeur de bar, dois-je le déclarer explicitement pour que lui aussi, il appelle le destructeur de foo ?

Merci de votre patience

Guiz

Tu peux pas appeller un destructeur explicitement (sauf dans un rare cas mais qui te concerne pas ici).
Et pas non plus :
b = new bar(); vu que b n'est pas un pointeur..

ps : en passant je vois pas bien l'intérêt de "réinitialiser" une telle variable..

[koala01]

Va appeler les constructeurs par défaut de bar et de foo, donc ici, pour réinitialiser la variable b si je la modifie, je dois explicitement appeler le destructeur

On n'appelle jamais (enfin on va dire comme sii, parce qu'on peut le faire dans un cas particulier qui ne ferai que compliquer les choses si on en parlait ici ) un destructeur explicitement...

et la ré-instancier en faisant un truc du genre : b = new bar(); ?

cela peut se faire, à condition que b soit un pointeur et que tu aies préalablement détruit b avec delete

Par contre, si ta variable n'est pas un pointeur, et que bar est assignable, tu peux, parfaitement faire quelque chose comme

Code :

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

1
2
3
bar temp; //création d'une variable temporaire de type bar
           // en invoquant son constructeur par défaut
b=temp; // assignation de cette variable a b

Et le destructeur de bar, dois-je le déclarer explicitement pour que lui aussi, il appelle le destructeur de foo ?

Non...

Le compilateur fournit de manière automatique quatre fonctions souvent appelée les "big four" s'il n'en rencontre pas les déclarations:

• un constructeur ne prenant pas d'argument ( " MaClass() " ) Note pour celui-ci que le compilateur ne le fournira que s'il n'y a aucun constructeur déclaré
• un constructeur par copie ( " MaClass(MaClass const &) " )
• un opérateur d'affectation ( " MaClass const & operator =(MaClass const & ) " )
• un destructeur ( " ~MaClass() " )

Si tu veux en savoir plus, renseigne toi sur les différentes formes canoniques de coplien )

Le constructeur fourni appellera le constructeur ne prenant aucun paramètre (qui doit exister !!! ) de chacun des membres de la classe dans l'ordre de leur déclaration et le destructeur appellera le destructeur de chacun des membres dans l'ordre inverse de leur construction.

NOTA : !!! cela ne fonctionne que pour les variables membre pour lesquelles tu n'a pas recours à l'allocation dynamique !!!

Ce comportement est, finalement, tout à fait normal, car la durée de vie d'une variable s'étend du moment de sa déclaration à l'accolade fermant la portée dans laquelle elle est déclarée.

Appliquée à une classe, la règle est donc que la durée de vie des variables membres d'une classe s'étend... à toute la durée de vie de l'instance de la classe considérée

Tu dois déclarer (et définir) un destructeur dans trois cas particuliers:

1. Soit parce qu'il doit faire "quelque chose de plus" que simplement détruire les membres de la classe (appeler une fonction qui aurait pour résultat de "désinscrire" l'instance auprès d'un gestionnaire, par exemple)
2. Soit parce que certains membres ont été créés en ayant recours à l'allocation dynamique de la mémoire, et qu'il est temps de libérer cette mémoire
3. Soit, enfin, parce que le destructeur doit pouvoir être utilisé pour détruire une instance de classe dérivée (nous sommes dans le cadre d'un héritage et de comportements polymorphes ) . Il doit alors être déclaré virtuel au moyen du mot clé virtual et implémenté même s'il ne fait rien d'autre de plus que de détruire les membres de la classes de manière automatique

[EDIT]grilled

[ZeGuizmo]

Eh bien ma foi, je n'ai plus d'interrogations

Merci beaucoup pour ces informations, elles éclaircissent beaucoup ce que certains cours laissent nébuleux

Bonnes fêtes,

Guiz