Discussion :

[stracoma]

Bonsoir à vous tous.
ce mot "const" qu'on met à la fin d'une méthode me taraude.peut être parce que je n'ai pas encore vu d'exemple où il est décisif. Prenant ce code simple:

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
#include <iostream>
 
using namespace std;
class Carre
{
private:
    double cote;
 
public:
    Carre(double x):cote(x){}
    double surface() const//sans const : ne chage rien
    {
        return cote * cote;
    }
    void set_cote(double x)
    {
        cote=x;
    }
 
    double get_cote()
    {
        return cote;
    }
 
};
int main()
{
    Carre carre1(25.0);
 
    cout << carre1.surface()<< endl;
    cout<<carre1.get_cote()<< endl;
    carre1.set_cote(30);
    cout<<carre1.surface()<<endl;
    cout<<carre1.get_cote()<<endl;
    return 0;
}

je ne trouve de différence que si j'écris la méthode surface de cette manière:

Code :

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

1
2
3
4
double surface() 
    {
        return cote *= cote;
    }

Pouvez vous m’écrire un petit code simple où const fait la différence. Merci

[darkman19320]

Salut,

Le mot const à la fin d'une méthode signifie que cette méthode ne modifiera pas l'objet appelant. Il faut l'utiliser au maximum pour éviter qu'un objet extérieur puisse modifier des valeurs qui n'ont pas lieux d'être.

Ton exemple est presque bon sauf pour la méthode get_cote où il faut que tu rajoutes le mot clef const à la fin de la méthode.

[Invité]

Hello !

Pour compléter ce qui a été dit plus haut, le mot const, associé à une méthode, indique au compilateur que la méthode en question n'a aucunement le droit de modifier les attributs de l'objet qui l'appelle. Par exemple, si tu écris :

Code :

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

1
2
3
4
5
int surface(void) const;
int MyCLass::surface(void) const
{
    return length * width;
}

Cela voudrait dire que la fonction surface n'a pas le droit de modifier les attributs de la classe MyClass. On utilise ainsi le mot clé const pour écrire ce qu'on appelle communément (dans d'autres langages) les getters. Mais l'utilisation ne se limite pas à cela. Pour éviter des erreurs de programmation, tu peux aussi faire le choix d'indiquer le mot const à chaque fois que cela a un sens : c'est-à-dire à chaque fois qu'une méthode d'une classe n'est pas sensée en modifier les attributs. Sur ce, passes une bonne journée.

[stracoma]

Si j'ai bien compris, par prudence, si on veut pas modifier les arguments , on ajout le mot const même si la foncion n'est pas censée les modifier

[Invité]

Si j'ai bien compris, par prudence, si on veut pas modifier les arguments , on ajout le mot const même si la foncion n'est pas censée les modifier

Lorqu'on ajoute le mot clé const à une méthode, le pointeur this (représentant une instance de la classe à un instant t) se comporte, lors de l'appelle de la méthode, comme un pointeur constant. Cela signifie que la dite méthode ne pourra pas modifier les attributs de la classe dans laquelle elle est définie (à moins d'utiliser les mutables). De plus, si dans une classe t'as deux méthodes qui portent la même signature mais qui diffèrent uniquement par la présence de l'identificateur const, le compilateur choisit tout seul la bonne méthode. Essayes le code suivant (j'ai mis des commentaires, n’hésites pas à les lire) :

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
#include <iostream>
#include <stdlib.h>
 
class Class {
    /* attributes */
 
    public:
        int attr1;
        int attr2;
        mutable int attr3_mutable;
 
    /* methods */
 
    public :
        Class() : attr1(0), attr2(0), attr3_mutable(0)
        {
        }
        ~Class() {}
 
        // Cette méthode ne peut pas changer l'état du pointeur this
        void updateAttributes(int a1, int a2) const
        {
            std::cout << "methode " << __func__ << " const" << std::endl;
 
            // décommentes ceci pour voir
            /*attr1 = a1;
            attr2 = a2;*/
 
            // un attribut mutable peut être cependant modifié
            attr3_mutable = 1;
        }
 
        void updateAttributes(int a1, int a2)
        {
            std::cout << "methode " << __func__ << std::endl;
 
            attr1 = a1;
            attr2 = a2;
            attr3_mutable = 1;
        }
};
 
int main()
{
    std::cout << "On a deux objets : l'un declare const et l'autre non" << std::endl;
    std::cout << "Remarques que le methode appelee n'est pas toujours la meme" << std::endl;
    std::cout << "-----------------------------------------------------------\n" << std::endl;
 
    Class c1_notConst;
    c1_notConst.updateAttributes(0, 0);
 
    const Class c2_const;
    c2_const.updateAttributes(0, 0);
 
    return 0;
}

Bon courage et n'hésites pas si t'as d'autres questions !

[renoo]

Si j'ai bien compris, par prudence, si on veut pas modifier les arguments , on ajout le mot const même si la foncion n'est pas censée les modifier

Cela sert aussi coté appelant, c'est une information importante on ne change pas l'objet avec une méthode "const". Ainsi si on appelle x fois une fonction membre const avec les memes arguments alors on obtiendra toujours le même résultat.

[Invité]

[...] Ainsi si on appelle x fois une fonction membre const avec les memes arguments alors on obtiendra toujours le même résultat.

Aïe, j'ai bien peur que non. Exemple :

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
class Class {
    /* attributes */
 
    public:
        mutable int x_mutable ;
 
    /* methods */
 
    public :
        Class() : x_mutable(0)
        {
        }
        ~Class() {}
 
        // Cette méthode ne peut pas changer l'état du pointeur this (sauf pour les attributs "mutable")
        int random(int n) const {
            x_mutable = n; // cette méthode, bien qu'étant déclarée const, peut modifier l'attribut x_mutable (c'est suffisant pour montrer qu'une méthode const peut permettre d'obtenir des résultats différents)
            return rand()%x_mutable ; // la méthode renvoie de plus un résultat aléatoire
        }
};
 
int main()
{
    srand(time(NULL));
 
    Class c;
    std::cout << c.random(2) << std::endl;
    std::cout << c.random(2) << std::endl;
}