Surcharge d'opérateurs

Version imprimable

Bonjour.

Je suis parti de cette video :
https://www.youtube.com/watch?v=BnMn...E0W_jN&index=8
où je tente de pousser l'exercice un peu plus loin en surchargeant l'opérateur "<<" agissant sur les "struct Comment" pour faire un effet de mise en page et je rencontre un soucis dont je ne trouve la cause !

Je déclare une struct Comment dont les instances prennent 2 paramètre (1 string et 1 int optionnel).
Ensuite, je surcharge l'opérateur << qui est supposé afficher le commentaire avec un petit effet de mise en page.
Le code suivant fonctionne :

Code:

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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
#include <iostream>
#include <list>
#include <string>
using namespace std;
 
struct Comment
{
    string Str;
    int Symbol;
    Comment(const string &str, const int &symbol= 2)
    {
        Str = str;
        Symbol = symbol;
    }
};
 
ostream &operator<<(ostream &COUT, Comment &comment)
{
    int size = comment.Str.size();
    for (int i = 0; i < size; i++)
    {
        COUT << comment.Symbol;
    }
    COUT << endl << comment.Str << endl;
    for (int i = 0; i < size; i++)
    {
        COUT << comment.Symbol;
    }
    return COUT;
}
 
struct YoutubeChannel
{
    string Name;
    int SubscribersCount;
 
    YoutubeChannel(string name, int subscribersCount)
    {
        Name = name;
        SubscribersCount = subscribersCount;
    }
    bool operator==(const YoutubeChannel channel) const
    {
        return this->Name == channel.Name;
    }
};
 
ostream &operator<<(ostream &COUT, YoutubeChannel &ytChannel)
{
    COUT << "Name: " << ytChannel.Name << endl;
    COUT << "SubscribersCount: " << ytChannel.SubscribersCount << endl;
    ;
    return COUT;
}
 
struct MyCollection
{
    list<YoutubeChannel> myChannels;
    void operator+=(YoutubeChannel &channel)
    {
        this->myChannels.push_back(channel);
    }
    void operator-=(YoutubeChannel &channel)
    {
        this->myChannels.remove(channel);
    }
};
 
ostream &operator<<(ostream &COUT, MyCollection &myCollection)
{
    for (YoutubeChannel ytChannel : myCollection.myChannels)
    {
        COUT << ytChannel << endl;
    }
    return COUT;
}
 
int main(void)
{
    YoutubeChannel yt1("CodeBeauty", 75000);
    YoutubeChannel yt2("Second channel", 70);
    YoutubeChannel yt3("third channel", 0);
 
    MyCollection myCollection;
    myCollection += yt1;
    myCollection += yt3;
    myCollection += yt2;
    cout << myCollection;
    myCollection -= yt1;
    Comment comment("Printing after removing a channel", 9);
    cout << comment;
    cout << endl;
    cout << myCollection;
 
    return 0;
}

Par contre celui-ci refuse de passer au compilateur alors que je ne tente que de remplacer mon paramètre optionnel "Symbol" int par un char :

Code:

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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
#include <iostream>
#include <list>
#include <string>
using namespace std;
 
struct Comment
{
    string Str;
    char Symbol;
    Comment(const string &str, const char &symbol= '&')
    {
        Str = str;
        Symbol = symbol;
    }
};
 
ostream &operator<<(ostream &COUT, Comment &comment)
{
    int size = comment.Str.size();
    for (int i = 0; i < size; i++)
    {
        COUT << comment.Symbol;
    }
    COUT << endl << comment.Str << endl;
    for (int i = 0; i < size; i++)
    {
        COUT << comment.Symbol;
    }
    return COUT;
}
 
struct YoutubeChannel
{
    string Name;
    int SubscribersCount;
 
    YoutubeChannel(string name, int subscribersCount)
    {
        Name = name;
        SubscribersCount = subscribersCount;
    }
    bool operator==(const YoutubeChannel channel) const
    {
        return this->Name == channel.Name;
    }
};
 
ostream &operator<<(ostream &COUT, YoutubeChannel &ytChannel)
{
    COUT << "Name: " << ytChannel.Name << endl;
    COUT << "SubscribersCount: " << ytChannel.SubscribersCount << endl;
    ;
    return COUT;
}
 
struct MyCollection
{
    list<YoutubeChannel> myChannels;
    void operator+=(YoutubeChannel &channel)
    {
        this->myChannels.push_back(channel);
    }
    void operator-=(YoutubeChannel &channel)
    {
        this->myChannels.remove(channel);
    }
};
 
ostream &operator<<(ostream &COUT, MyCollection &myCollection)
{
    for (YoutubeChannel ytChannel : myCollection.myChannels)
    {
        COUT << ytChannel << endl;
    }
    return COUT;
}
 
int main(void)
{
    YoutubeChannel yt1("CodeBeauty", 75000);
    YoutubeChannel yt2("Second channel", 70);
    YoutubeChannel yt3("third channel", 0);
 
    MyCollection myCollection;
    myCollection += yt1;
    myCollection += yt3;
    myCollection += yt2;
    cout << myCollection;
    myCollection -= yt1;
    Comment comment("Printing after removing a channel", 'F');
    cout << comment;
    cout << endl;
    cout << myCollection;
 
    return 0;
}

Je ne comprends absolument pas pourquoi cela refuse de fonctionner .
Quelqu'un pourrait il m'aiguiller sur mon erreur ou bien pourquoi cela n'est pas sensé fonctionner ?

12/03/2022, 16h28
Mat.M

pourquoi ne pas passer simplement const string & Symbol="&" ?
Le problème de passer un char c'est que la variable locale à la structure Comment est de type string et elle ne trouve pas le caractère de terminaison en passant un char.
En C/C++ les chaînes de caractères se terminent par '\0'.
Puis on évite les structures car les membres de la classe sont publics par défaut

Merci beaucoup pour la réponse rapide.

Je me doutait qu'il pouvait y avoir une subtilité avec char et j'avais donc essayé avec string. J'avais cependant du faire une bourde quelque part car ça ne fonctionnait pas quand même.

Je ne comprend pas trop pourquoi tu dis "la variable locale à la structure Comment est de type string"

En tout cas, ça fonctionne comme je le souhaite;
Merci.
Sinon au lieu d'utiliser une struct, j'aurai du utiliser une class ? J'ai essayé mais n'ai pour l'instant pas réussi à faire un code fonctionnel.

Code:

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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
#include <iostream>
#include <list>
#include <string>
using namespace std;
 
struct Comment
{
    string Str;
    string Symbol;
    Comment(const string &str, const string &symbol = "*")
    {
        Str = str;
        Symbol = symbol;
    }
};
 
ostream &operator<<(ostream &COUT, Comment &comment)
{
    int size = comment.Str.size();
    for (int i = 0; i < size; i++)
    {
        COUT << comment.Symbol;
    }
 
    COUT << endl
         << comment.Str << endl;
    for (int i = 0; i < size; i++)
    {
        COUT << comment.Symbol;
    }
 
    return COUT;
 
    /*void print_symbol(const Comment &comment)
    {
        int size = comment.Str.size();
        for (int i = 0; i < size; i++)
        {
            COUT << comment.Symbol;
        }
    }*/
}
 
struct YoutubeChannel
{
    string Name;
    int SubscribersCount;
 
    YoutubeChannel(string name, int subscribersCount)
    {
        Name = name;
        SubscribersCount = subscribersCount;
    }
    bool operator==(const YoutubeChannel channel) const
    {
        return this->Name == channel.Name;
    }
};
 
ostream &operator<<(ostream &COUT, YoutubeChannel &ytChannel)
{
    COUT << "Name: " << ytChannel.Name << endl;
    COUT << "SubscribersCount: " << ytChannel.SubscribersCount << endl;
    ;
    return COUT;
}
 
struct MyCollection
{
    list<YoutubeChannel> myChannels;
    void operator+=(YoutubeChannel &channel)
    {
        this->myChannels.push_back(channel);
    }
    void operator-=(YoutubeChannel &channel)
    {
        this->myChannels.remove(channel);
    }
};
 
ostream &operator<<(ostream &COUT, MyCollection &myCollection)
{
    for (YoutubeChannel ytChannel : myCollection.myChannels)
    {
        COUT << ytChannel << endl;
    }
    return COUT;
}
 
int main(void)
{
    YoutubeChannel yt1("CodeBeauty", 75000);
    YoutubeChannel yt2("Second channel", 70);
    YoutubeChannel yt3("third channel", 0);
 
    MyCollection myCollection;
    myCollection += yt1;
    myCollection += yt3;
    myCollection += yt2;
    cout << myCollection;
    myCollection -= yt1;
    Comment comment("Printing after removing a channel", "%");
    cout << comment;
    cout << endl;
    cout << myCollection;
 
    return 0;
}

12/03/2022, 20h24
Mat.M

bonsoir la variable locale à la struct Comment c'est String "Str"

Selon vos conseils, j'ai transformé mes struct en class, mais ça ne compile pas à cause de ces lignes :

Code:

1
2
3
4
    bool operator==(const YoutubeChannel channel) const
    {
        return this->getName() == channel.getName();
    }

Pour mes autres struct, celà a fonctionné. Mais je ne suis pas du tout à l'aise avec ce "this->"

Code complet :

Code:

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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
#include <iostream>
#include <list>
#include <string>
using namespace std;
 
class Comment
{
private:
    string Str;
    string Symbol;
 
public:
    Comment(const string &str, const string &symbol = "*")
    {
        Str = str;
        Symbol = symbol;
    }
    //accesseur
    string getStr(void)
    {
        return Str;
    }
    string getSymbol(void)
    {
        return Symbol;
    }
};
 
ostream &operator<<(ostream &COUT, Comment &comment)
{
    int size = comment.getStr().size();
    for (int i = 0; i < size; i++)
    {
        COUT << comment.getSymbol();
    }
 
    COUT << endl
         << comment.getStr() << endl;
    for (int i = 0; i < size; i++)
    {
        COUT << comment.getSymbol();
    }
 
    return COUT;
 
    /*void print_symbol(const Comment &comment)
    {
        int size = comment.Str.size();
        for (int i = 0; i < size; i++)
        {
            COUT << comment.Symbol;
        }
    }*/
}
 
class YoutubeChannel
{
private:
    string Name;
    int SubscribersCount;
 
public:
    YoutubeChannel(string name, int subscribersCount)
    {
        Name = name;
        SubscribersCount = subscribersCount;
    }
    //accesseur :
    string getName(void)
    {
        return Name;
    }
 
    int getSubscribersCount(void)
    {
        return SubscribersCount;
    }
 
    bool operator==(const YoutubeChannel channel) const
    {
        return this->getName() == channel.getName();
    }
};
 
ostream &operator<<(ostream &COUT, YoutubeChannel &ytChannel)
{
    COUT << "Name: " << ytChannel.getName() << endl;
    COUT << "SubscribersCount: " << ytChannel.getSubscribersCount() << endl;
    ;
    return COUT;
}
 
struct MyCollection
{
    list<YoutubeChannel> myChannels;
    void operator+=(YoutubeChannel &channel)
    {
        this->myChannels.push_back(channel);
    }
    void operator-=(YoutubeChannel &channel)
    {
        this->myChannels.remove(channel);
    }
};
 
ostream &operator<<(ostream &COUT, MyCollection &myCollection)
{
    for (YoutubeChannel ytChannel : myCollection.myChannels)
    {
        COUT << ytChannel << endl;
    }
    return COUT;
}
 
int main(void)
{
    YoutubeChannel yt1("CodeBeauty", 75000);
    YoutubeChannel yt2("Second channel", 70);
    YoutubeChannel yt3("third channel", 0);
 
    MyCollection myCollection;
    myCollection += yt1;
    myCollection += yt3;
    myCollection += yt2;
    cout << myCollection;
    myCollection -= yt1;
    Comment comment("Printing after removing a channel", "%");
    cout << comment;
    cout << endl;
    cout << myCollection;
 
    return 0;
}

12/03/2022, 22h50
foetus

Ton problème est trivial :mrgreen: "error: passing ‘const YoutubeChannel’ as ‘this’ argument discards qualifiers [-fpermissive]"

En gros, ton operateur == dit qu'il ne modifiera pas la classe (constant). Or ta méthode getName() ne garantie pas l'immutabilité de ta classe.
1 méthode/objet constant(e) doit appeler que des méthodes constantes.

Comment faire ? Je ne sais pas :zoubi: soit refaire la logique de ta classe, soit passer par 1 const_cast.

Citation:

Envoyé par hary66

Sinon au lieu d'utiliser une struct, j'aurai du utiliser une class ?

En C++, la seule différence entre 1 struct et 1 class, c'est l'encapsulation : publique et privée respectivement.

Citation:

Envoyé par hary66

Mais je ne suis pas du tout à l'aise avec ce "this->"

Le this est optionnel. Dans ton code, tu n'en as pas besoin :mrgreen:

Il est là pour lever les ambiguïtés pour différencier les attributs/ méthodes de ta classe des paramètres qui ont le même nom.
Souvent on rajoute 1 underscore à la fin aux attributs ou 1 "input" par exemple aux paramètres.

Il sert aussi à retourner/ passer 1 pointeur/ reférence de la classe.
12/03/2022, 23h23
hary66

Citation:

Ton problème est trivial :mrgreen: "error: passing ‘const YoutubeChannel’ as ‘this’ argument discards qualifiers [-fpermissive]"

En gros, ton operateur == dit qu'il ne modifiera pas la classe (constant). Or ta méthode getName() ne garantie pas l'immutabilité de ta classe.
1 méthode constante doit appeler que des méthodes constantes.

Comment faire ? Je ne sais pas :zoubi: soit refaire la logique de ta classe, soit passer par 1 const_cast.

Je suis largué là,

Citation:

Le this est optionnel. Dans ton code, tu n'en as pas besoin :mrgreen:

Il est là pour lever les ambiguïtés pour différencier les attributs/ méthodes de ta classe des paramètres qui ont le même nom.
Souvent on rajoute 1 underscore à la fin aux attributs ou 1 "input" par exemple aux paramètres.

Il sert aussi à retourner/ passer 1 pointeur/ référence de la classe.

Ce que je retient est que même si optionnel, il sert tout de même à lever les ambiguïtés, ce qui pour moi est bien utile !
13/03/2022, 00h28
foetus
Citation:

Envoyé par hary66

Je suis largué là

Il te manque des cours :mrgreen: :aie: C'est le mot clef const à la fin de la ligne de la définition de ton opérateur.
Donc tu as copié/ collé sans regarder ce qu'il y avait dans le code :whistle:
Code:

1 2 3 4 bool operator==(const YoutubeChannel channel) const { return this->getName() == channel.getName(); }
13/03/2022, 10h31
hary66
J'ai du supprimer les 2 CONST pour que ça passe :
Code:

1 2 3 4 bool operator==(YoutubeChannel channel) { return this->getName() == channel.getName(); }
Il est vrai que je n'avait pas compris l'utilité des CONST à part le fait qu'il était prudent de les mettre étant donné que l'on ne modifiait pas la variable "YoutubeChannel" (pour le premier const).
Pour le second const, je n'ai en effet pas compris sa nécessité qui était indiqué dans la vidéo tuto.

Du reste, nulle part on ne tente de modifier la variable "YoutubeChannel", et je ne comprend pas bien pourquoi il y a incomparabilité à indiquer CONST.

Concernant les cours, c'est sans doute vrai, mais c'est en pratiquant que l'on apprend et comprend mieux les choses. J'ai lu des tas de cours, mais il faut faire des exercices pour bien appréhender tout le contenu du cours.

Bonjour,

Le problème est dû au fait qu'il manque plein de const. Le tuto explique très mal pourquoi il faut ces const.
En fait, il faut mettre const partout sauf si le paramètre sera modifié ou si l'objet sera modifié. Ici il manque le fait d'indiquer que string getName() est const et bien évidemment la fonction de comparaison doit rester const car elle ne modifie ni l'objet ni le paramètre.
Ça donne:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 // les accesseurs sont TOUJOURS const, et retournent de préférence une const référence string const& getName() const { return Name; } int getSubscribersCount() const { return SubscribersCount; } // les mutateurs, eux ne sont jamais const, forcément ils modifient l'objet void setSubscribersCount( int subscribers_count ) { SubscribersCount = subscribers_count ; } // comparaison, ni l'objet courant ni le paramètre ne sont modifiés d'où les 2 const bool operator==( YoutubeChannel const& channel ) const { return getName() == channel.getName(); }
Il en manque plein d'autres. Il y a d'ailleurs plein d'erreurs dans le tuto. Un des principes de base du C++ est la const-correctess, je t'encourage à te renseigner sur ce sujet.

13/03/2022, 14h21
hary66

Il faut bien comprendre qu'un débutant ne peut absorber toutes les finesses et la rigueur du C++.
Ce qui explique peut être les manques de précision du tuto.
En tout cas, j'espère que ce ne sont pas réellement des erreurs comme dit dans votre réponse, mais plutôt des "allégement".

Quand à la const-correctess, ça me semble une finesse de programmeur professionnel dont je n'ai jamais entendu parler auparavant.
Encore une fois, il est difficile en tant que débutant de digérer tout d'un coup.
13/03/2022, 18h58
jo_link_noir

Citation:

Envoyé par hary66

Quand à la const-correctess, ça me semble une finesse de programmeur professionnel dont je n'ai jamais entendu parler auparavant.

Absolument pas. La const-correctness est une chose qui se voit très tôt dans n'importe quel bon cours. C'est à dire dans le chapitre concernant la création de fonction. Le mot clef const peut se voir même avant (introduction en douceur) puis dans les fonctions membres lorsqu'on parle de structure et classe. Quand je regarde le cours de zeste de savoir, const est introduit en même temps que les variables.

La const-correctness n'est que l'application d'une règle simple: mettre const quand on ne modifie pas l'objet.

Lorsque je vois votre code, certains point me font dire que vos tutos sont plutôt moyens: utilisation de using namespace std, utilisation de std::list (il faut de très bonne raison pour la préférer à std::vector), pas d'utilisation de la liste d'initialisation, etc.
13/03/2022, 19h40
hary66

Arf !

J'avais réussi à bricoler un peu ce WE avec les class et la surcharge d'opérateur et là, vous me ficher tout à terre !
Ca me décourage !

Pour le const, en effet, je l'utilisait un peu, c'est un bon garde fou.
Pour le using namespace std, quand on bricole, c'est vraiment pénible d'écrire std:: à chaque fois ! Après, je peu comprendre que ce soit plus rigoureux.

Pour l'utilisation de std::list au lieu de std::vector, je n'ai pas de justification.

Salut,

Citation:

Envoyé par hary66

J'ai du supprimer les 2 CONST pour que ça passe :

Holla!!!!

Voici une petite règle qui devrait t'éviter énormément de soucis par la suite:

Citation:

On ne supprime JAMAIS le mot clé const si on a de bonne raisons de considérer que la donnée manipulée ne doit pas être modifiée

On pourrait même aller plus loin, en fait...

On sait que toute donnée qui n'est pas explicitement indiquée comme étant constante cours le risque majeur d'être modifiée (Merci Mr Obvious :D ).

C'est ce qui se passe "par défaut" comme par exemple dans le code
Code:

1 2 3 4 5 int main(){ int i = 3; // i n'est pas déclaré constant /* ... */ i = 10; // je peux donc modifier sa valeur }
Hé bien, je vais peut-être te surprendre, mais cette c**rie est sans doute à l'origine de base de 90% des bugs que tu pourras rencontrer.

Et ce pour une raison toute simple:

On conseille généralement de transmettre toutes les données "dont la taille est supérieure à celle d'un type primitif (comprend: dés que l'on n'a pas affaire à un char, un short, un int, un long, un long long, un float, un double ou un long double, ainsi que les versions "unsigned" des types qui les supportent) de transmettre la donnée sous forme de référence pour éviter les problèmes liés à la "perte de temps" (et de ressources) lors de la copie.

Seulement, une référence va -- littéralement -- agir comme un alias de la donnée d'origine au niveau de la fonction appelée.

Cela implique que si tu modifie un paramètre (transmis par référence ou par pointeur) dans une fonction, les modifications que tu apportées dans la fonction vont se répercuter au niveau de la variable d'origine. C'est le cas dans un code qui pourrait être aussi simple que
Code:

1 2 3 4 5 6 7 8 9 void foo(int & param){ param += 3; // ajoute 3 à la valeur de param } int main(){ int i = 6; foo(i); // appelle foo en lui transmettant i par référence std::cout<<i<<"\n"; // affiche ... 9, car les modifications apportées par // foo ont été répercutées sur i }
Ce code est tout à fait valide, et peut même être "parfaitement justifié" dans certaines situations... Pour autant que l'on ait la certitude absolue que le fait de modifier la valeur de la variable "d'origine" soit réellement justifié et que l'utilisateur de notre fonction foo ne fera pas une connerie en l'appelant dans une situation dans laquelle cela ne se justifie pas ou qui pourrait poser problème.

Hé bien, il faut se dire que de telles situations ne peuvent tout simplement pas arriver lorsqu'une donnée est déclarée constante, et pour cause, vu qu'on dit explicitement au compilateur que "cette donnée n'est pas destinée à être modifiée" (encore merci Mr Obvious :D ).

Or, le compilateur va se mettre à râler chaque fois qu'il se rendra compte qu'une donnée "soit disant constante" risque d'être modifiée. Et il sera généralement "plus têtu" que toi ;)

Si bien que "dans l'idéal", nous ne devrions faire en sorte de ne travailler -- du moins, dans la mesure du possible -- qu'avec des données constantes

Au lieu de supprimer le mot clé const à gauche et à droite "pour que le compilateur accepte de faire son travail", tu devrais donc envisager de rajouter ce mot clé "partout où le compilateur se plaint" de passer d'une donnée constante à une donnée non constante.

Parce que c'est -- justement -- en refusant d'apporter des (éventuelles) modifications à une donnée "qui n'est pas sensée être modifiée" qu'il pourra t'éviter une très grosse majorité des soucis.

A tel point que, si j'avais un ordre logique à conseiller, ce serait plutôt:

on déclare toutes les données et tous les paramètres comme constant(e)s "par défaut"
on déclare toutes les fonctions membres de nos classes comme "ne permettant pas la modification de l'objet à partir duquel elles sont appelées" (constante, donc) "par défaut"
on ne supprime le mot clé const des fonctions membres que ... s'il est "évident" que le comportement attendu de la fonction considérée consiste à modifier l'objet à partir duquel elle est appelée, et que l'on n'a donc "pas d'autre choix"
on ne supprime le mot clé const d'une donnée (ou d'un paramètre) que ... s'il est évident que la donnée manipulée devra être modifiée, et que l'on n'a donc "pas d'autre choix"
on limite le fait de manipuler une donnée "non constante" à des portions de code qui soient les plus courtes possibles et qui, "dans l'idéal", se limitent au seul fait d'apporter la modification envisagée

PS savais tu, d'ailleurs, que c'est -- en gros -- l'approche suivie "par défaut" par la grosse majorité des langages dit "fonctionnels" :question:

13/03/2022, 22h34
foetus

on peut rajouter qu'il y a 3 types de paramètres : entrée, sortie, entrée/ sortie.
Et donc le mot clef const permet d'avoir les paramètres entrée, et les pointeurs/ références des paramètres sortie et entrée/ sortie.
Ensuite, les P.O.D (plain old data) n'ont pas besoin d'être constants parce qu'elles sont transmises par valeur. C'est surtout pour les pointeurs/ références.

Lien wiki paramètre en français

Citation:

Envoyé par foetus

Et donc le mot clef const permet d'avoir les paramètres entrée, et les pointeurs/ références des paramètres sortie et entrée/ sortie.
Ensuite, les P.O.D (plain old data) n'ont pas besoin d'être constants parce qu'elles sont transmises par valeur. C'est surtout pour les pointeurs/ références.

Lien wiki paramètre en français

Et encore, les POD ne sont finalement qu'une de ces "rares occasions" dont je parlais, et rien n'empêche de les transmettre par référence (constante en cas de besoin)...

Prenons l'exemple tout simple d'une structure proche de
Code:

1 2 3 4 5 struct Color{ int red; int green; int blue; };
ou de
Code:

1 2 3 4 5 struct Point{ float x; float y; float z; };
Voici bel et bien deux structures que l'on pourra considérer comme étant des POD, vu qu'elles ne font vraiment qu'amalgamer des données (de type primitif) qui ne prennent réellement leur sens que parce qu'elles sont destinées à "travailler ensemble".

Cependant, on peut clairement considérer que ce sont des données dont "la taille est supérieure à celle d'un type primitif" (surtout si le padding entre en jeu :P).

Personnellement, si je dois transmettre des données de ces types, je le ferai sous la forme de référence (éventuellement constante) plutôt que par valeur, et ce, malgré le fait que la création d'une copie ne coute sans doute "pas beaucoup plus cher" que le passage par référence ;)

De plus, lorsqu'une de ces données est fournie en paramètre à une fonction, il reste la question de savoir si les modifications apportée au paramètre par la fonction appelée doivent être répercutées sur la donnée d'origine ou non.

Et si c'est le cas, la véritable question finale sera de savoir si on préfère écrire un code proche de
Code:

1 2 3 4 int main(){ Point p; laFonctionQuiModifieUneReference(p); // transmis par référence, les modifications sont répercutées }
ou
Code:

1 2 3 4 5 int main(){ point p; p = laFonctionQuiModifieUneCopie(p); // transmis par valeur, les modifications étant récupérées // au travers du retour de la fonction }
Ma "fainéantise naturelle" tendrait sans doute à préférer la première version :D

14/03/2022, 14h27
Bousk

Ça a sûrement déjà été dit mais ton code nmanque de const-correctness, fait des copies partout et tes opérateurs += sont faux.
La syntaxe normale est CLASS& operator+=(const CLASS& other) { ... return *this; }.
Ce serait bien de donner l'erreur que ton compilo te retourne, parce que "ça marche pas" en fournissant 100 lignes de code, et mentionnant les opérateurs << qui semblent corrects, ça aide pas à t'aider...
Et using namespace std; ne devrait pas être utilisé ici.

Je ne suis pas certain de bien comprendre :

Citation:

Envoyé par koala01

Code:

1
2
Point p;
void laFonctionQuiModifieUneReference(p); // transmis par référence, les modifications sont répercutée

Code:

1
2
3
point p;
p = laFonctionQuiModifieUneCopie(p); // transmis par valeur, les modifications étant récupérées
                                     // au travers du retour de la fonction

ne devrait pas plutot être :

Code:

1
2
Point p;
void laFonctionQuiModifieUneReference(Point &p); // transmis par référence, les modifications sont répercutée

et pour m'assurer que je comprend bien :

Code:

1
2
3
4
5
6
7
Point p;
Point laFonctionQuiModifieUneCopie(Point point){
(modification de point;)
return point;
}
p = laFonctionQuiModifieUneCopie(p); // transmis par valeur, les modifications étant récupérées
                                     // au travers du retour de la fonction

15/03/2022, 11h35
Guesset

Bonjour,

Non, l'écriture de Koala est correcte mais c'est une écriture d'usage et non de déclaration de la fonction (qui correspond à ce que tu écris).

Salutations

Je pleure ! :cry::cry::cry:
Je ne comprend rien du tout !
Code:

1 2 3 Point p; void laFonctionQuiModifieUneReference(p); // transmis par référence, les modifications sont répercutée
L'usage d'une fonction n'est pas précédé par le type de renvoi normalement !
D'autre part, si cette fonction modifie une référence, elle doit prendre une référence (ou un pointeur) en paramètre, hors p est une variable de type Point, le paramètre ne devrait-il donc pas être présenté à la fonction précédé du & ?

Pour le second extrait de code, mis à par p déclaré de type point au lieu de type Point, on peut en effet comprendre. Mais si je veut être certain de bien saisir, il me semble que cette écriture n'est pas fausse ?
Code:

1 2 3 4 5 6 7 Point p; Point laFonctionQuiModifieUneCopie(Point point){ (modification de point;) return point; } p = laFonctionQuiModifieUneCopie(p); // transmis par valeur, les modifications étant récupérées // au travers du retour de la fonction
Je m'excuse d'ergoter de manière si insistante, mais je veux clarifier tout doutes.

15/03/2022, 21h12
foetus

Effectivement il y a 1 void en trop ... mais tu peux le mettre entre parenthèse pour dire que tu ne veux pas du retour <- à vérifier pour effacer les warnings.

void laFonctionQuiModifieUneCopie(Point point), appel laFonctionQuiModifieUneCopie(p) : tu appelles par valeur, paramètre entrée mais tu as 1 copie
void laFonctionQuiModifieUneCopie(Point& point), appel laFonctionQuiModifieUneCopie(p) : paramètre entrée/ sortie ou sortie
void laFonctionQuiModifieUneCopie(Point* point), appel laFonctionQuiModifieUneCopie(&p) : paramètre entrée/ sortie ou sortie
Point laFonctionQuiModifieUneCopie(const Point& point), appel laFonctionQuiModifieUneCopie(p) : paramètre entrée mais peut-être appel de l'optimisation RVO (Return Value Optimization)
15/03/2022, 21h22
koala01
Ce qu'il faut comprendre, c'est que tu pourrais avoir deux fonctions qui ressembleraient à
Code:

1 2 3 4 void laFonctionQuiModifieUneReference(Point & p){ // modification du point "en interne" }
ou à
Code:

1 2 3 4 Point laFonctionQuiModifieUneCopie(Point p){ // modification du point return p; // renvoie le point modifié }
Si je fais appel à la première fonction sous la forme de
Code:

1 2 3 4 5 int main(){ Point lePoint; laFonctionQuiModifieUneReference(lePoint); /* ... */ }
j'obtiendrai au final (comprends: après l'exécution de la fonction) exactement le même résultat que si je fais appel à la deuxième fonction sous la forme de
Code:

1 2 3 4 5 int main(){ Point lePoint; lePoint = laFonctionQuiModifieUneCopie(lePoint); /* ... */ }
La différence porte sur la manière dont le résultat est obtenu:

La première fonction va travailler avec une référence (d'où l'esperluette entre Point et p): on signale que p est destiné à agir comme "un alias" de lePoint.

A titre de comparaison, nous pourrions dire que p est l'équivalent de mon pseudo (koala01) sur le forum: Quand tu vois une réponse postée par "koala01", c'est en fait ... moi (Philippe Dunski) qui l'ai écrite.

Si tu viens à insulter ou à congratuler "koala01", l'insulte ou la congratulation s'adressera toujours à une personne "bien vivante": moi (Philippe Dunski).

Hé bien, le passage par référence agit exactement de la même manière: si la fonction appelée (AKA laFonctionQuiModifieUneReference) manipule un point qu'elle connait comme étant nommé p, il faut savoir que c'est en fait la donnée lePoint, qui existe au niveau de la fonction appelante, qui sera modifiée.

A l'inverse, lorsque le paramètre est transmis par valeur, il n'y a aucun lien particulier entre la donnée p -- qui est la donnée manipulée par laFonctionQuiModifieUneCopie -- et la donnée qui a été transmise en paramètre lorsque la fonction a été appelée (la donnée lePoint).

A ceci près, quand même, que p est une copie de lePoint, et que les deux peuvent dont être modifiés de manière indépendante.

Et comme p va cesser d'exister une fois que l'exécution de la fonction sera achevée, si on veut récupérer les modification apportées par la fonction, il faut ... renvoyer le résultat modifié. Et bien sur, veiller à récupérer ce résultat modifié dans la variable lePoint si l'on souhaite que lePoint "subisse" les modifications qui auront été apportées à p.

Citation:

L'usage d'une fonction n'est pas précédé pas le type de renvoi normalement !

En effet... c'est bel et bien une erreur de ma part (je la corrige immédiatement :D ).

Ce qui n'empêche que le code reste malgré tout parfaitement correct et valide dans le cadre de l'appel d'une fonction ;)

Citation:

D'autre part, si cette fonction modifie une référence, elle doit prendre une référence (ou un pointeur) en paramètre, hors p est une variable de type Point, le paramètre devrait dont être présenté à la fonction précédé du &.

Héhé ... non...

Le problème est que l'esperluette (&) représente plusieurs choses en fonction du contexte dans lequel il est utilisé.
- Lorsque l'esperluette se trouve entre un type de donnée et l'identifiant d'une donnée du type indiqué, nous avons affaire à une déclaration et elle représente le fait que la donnée sera traitée comme étant une référence.
- Lorsque l'esperluette n'est pas précédée d'un type de donnée, nous sommes alors dans le cadre de l'accès à la donnée indiquée et elle représente l'opérateur "address of", c'est à dire l'opérateur qui permet de récupérer l'adresse mémoire à laquelle la donnée se trouve actuellement.
Il y a donc plusieurs circonstances à distinguer:
Code:

1 2 3 void foo(Point & p){ /* ... */ }
Point & p correspond à la ... déclaration d'un paramètre qui sera "une référence sur un point" et auquel nous pourrons accéder au travers de l'identifiant p.
Code:

1 2 3 Point lePoint; Point & laRef = lePoint;
Point & laRef indique laRef comme étant une "référence sur un point" à laquelle est associée la donnée originale lePoint;

NOTA: les références doivent systématiquement être définies, c'est à dire qu'il faut impérativement indiquer quelle est la "donnée d'origine" associée à une référence.

NOTA: Une fois que la "donnée d'origine" a été associée à une référence, il devient impossible d'y associer une autre donnée pour toute la durée de vie de la référence. Il ne serait donc pas possible, après avoir associé lePoint à laRef (ce qui est indispensable), de faire en sorte d'utiliser laRef pour référencer une éventuelle donnée autrePoint.
Code:

1 2 3 4 int main(){ Point lePoint; foo(&lePoint); }
&lePoint agit comme un accès à la donnée nommée lePoint afin de faire appel à la fonction foo. L'esperluette va donc être interprétée comme étant l'opérateur "address of", si bien que ce sera ... l'adresse mémoire à laquelle se trouve effectivement lePoint (autrement dit, un pointeur sur la donnée lePoint) qui sera transmise à foo
16/03/2022, 21h20
hary66
Je pense que c'est plus clair.

A partir de cette partie, c'est plus trouble.
Code:

1 2 3 Point lePoint; Point & laRef = lePoint;
J'ai pu tester que si je modifie lePoint, laRef n'est pas modifié. (même adresse pour lePoint et laRef, &lePoint et &laRef indiquent une seule et même adresse.

Par contre, avec ce code :
Code:

1 2 3 Point lePoint; Point laRef = lePoint;
j'ai pu tester que si je modifie lePoint, laRef est aussi modifié (les modifications faites sur le point se répercutent sur laRef) et &lePoint et &laRef indiquent 2 adresses distinctes.

Sinon, cette partie
Code:

1 2 3 4 int main(){ Point lePoint; foo(&lePoint); }
me reste obscure et ne compile pas chez moi, ce qui ne me surprend pas trop puisque foo attend une variable en paramètre alors qu'on lui donne une référence !
17/03/2022, 13h34
Bousk
Je me demande bien ce que tu as testé parce que ce que tu racontes est totalement faux.
Code:

1 2 Point lePoint; Point & laRef = lePoint;
laRef et lePoint sont la même variable. Changer l'un va changer l'autre.
Code:

1 2 Point lePoint; Point laRef = lePoint;
Ce sont 2 variables totalement indépendantes, donc évidemment changer l'une ne va avoir absolument aucun impact sur l'autre.
Citation:
Code:

1 2 3 4 int main(){ Point lePoint; foo(&lePoint); }

[...] foo attend une variable en paramètre alors qu'on lui donne une référence !
Une référence est une variable, et ton vocabulaire est mauvais. La syntaxe & prend l'adresse d'une variable qui est représentée par la notation pointeur.

Citation:
Envoyé par hary66
Je pense que c'est plus clair.

A partir de cette partie, c'est plus trouble.
Code:

1 2 3 Point lePoint; Point & laRef = lePoint;
J'ai pu tester que si je modifie lePoint, laRef n'est pas modifié. (même adresse pour lePoint et laRef, &lePoint et &laRef indiquent une seule et même adresse.
Tu as donc du faire une c...rie, car je peux t'assurer qu'un code proche de
Code:

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 #include <iostream> /* j'utilise une structure car cela permettra de modifier plus facilement les données de bases ;) */ struct Point{ Point():Point{0,0,0}{ } Point(int x, int y, int z):x{x},y{y},z{z}{ } int x; int y; int z; }; /* surcharge de l'opérateur << adaptée à un Point */ std::ostream & operator <<(std::ostream & os, Point const & p){ os<<"x : "<<p.x<<"\n" <<"y : "<<p.y<<"\n" <<"z : "<<p.z<<"\n"; return os; } int main(){ /* Créons un point dont les valeurs sont * x = 1 * y = 2 * z = 3 */ Point lePoint{1,2,3}; std::cout<<"lePoint affiche sans surprise\n" <<lePoint; Point & laRef = lePoint; std::cout<<"laRef présente les valeurs de lePoint\n" <<laRef; /* Modifions les valeurs de lePoint : */ lePoint.x *=2; lePoint.y *=2; lePoint.z *=2; std::cout<<"toutes les donnees de lePoint changent:\n" <<lePoint; std::cout<<"qu'en est-il de laRef?\n" <<laRef; /* modifions laRef pour qu'elle corresponde à * x = 10 * y = 12 * z = 15 */ laRef.x = 10; laRef.y = 12; laRef.z = 15; std::cout<<"les valeurs de laRef changent\n" <<laRef; std::cout<<"Qu'en est il de lePoint?\n" <<lePoint; return 0; }
donnera un résultat équivalent à
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 lePoint affiche sans surprise x : 1 y : 2 z : 3 laRef présente les valeurs de lePoint x : 1 y : 2 z : 3 toutes les donnees de lePoint changent: x : 2 y : 4 z : 6 qu'en est-il de laRef? x : 2 y : 4 z : 6 les valeurs de laRef changent x : 10 y : 12 z : 15 Qu'en est il de lePoint? x : 10 y : 12 z : 15
La preuve ==>ICI<==.
Citation:
Par contre, avec ce code :
Code:

1 2 3 Point lePoint; Point laRef = lePoint;
j'ai pu tester que si je modifie lePoint, laRef est aussi modifié (les modifications faites sur le point se répercutent sur laRef) et &lePoint et &laRef indiquent 2 adresses distinctes.
Absolument faux, car la donnée laRef n'est pas une référence ici, mais simplement une variable "tout ce qu'il y a de plus normal", si ce n'est qu'on lui aura donné, à la base, les même valeurs que pour lePoint

LaRef et LePoint sont donc deux variables qui vont évoluer de manière totalement indépendante: Si tu modifie laRef, il n'y a aucune raison pour que lePoint soit modifié en retour, et inversement.
Citation:
Sinon, cette partie
Code:

1 2 3 4 int main(){ Point lePoint; foo(&lePoint); }
me reste obscure et ne compile pas chez moi,
Il n'était pas sensé compiler non plus, vu qu'il n'a absolument rien à voir avec les deux morceaux de code qui le précèdent.

Il faut prendre l'habitude de lire correctement -- au besoin plusieurs fois -- les réponses qui te sont données, parce que chaque mot compte!

J'avais cru qu'il était clair, après avoir précisé que

Citation:

Il y a donc plusieurs circonstances à distinguer:

que j'allais donner trois exemples qui n'ont rien à voir les uns avec avec les autres, mais, comme dit mon vénéré père: il faut laisser croire les béguines, elles sont spécialistes et payées pour :aie:

Toujours est-il que ces trois codes sont parfaitement corrects, si ce n'est qu'ils sont tous les trois sortis de leur contexte et qu'il faudra donc les adapter avant de pouvoir en faire quoi que ce soit.

Citation:

ce qui ne me surprend pas trop puisque foo attend une variable en paramètre alors qu'on lui donne une référence !

Attention, je le redis, et on te le répétera à l'envie: en informatique, qui ne comprend que le fait que le courent passe à un point donné ou non, chaque mot compte.

Comme l'a si bien fait remarquer Bousk, tu as un gros problème de vocabulaire:

Une variable représente n'importe quelle donnée qui est susceptible d'être modifiée. On peut la mettre en opposition avec le terme constante, qui représente une donnée qui ne sera jamais modifiée.

Une variable peut prendre différentes formes:
une valeur : c'est ce que l'on obtiens lorsque l'on écrit un code comme int i = 3; car i est une donnée (qui peut être modifiée) dont la valeur est 3
une référence: un alias sur une autre donnée (qui doit exister) que l'on obtient avec un code comme Point & laReference = lePoints; // laReference est un alias de lepoint on donne, dans un contexte particulier, un "autre nom" pour désigner la même donnée, mais tout ce qu'une des donnée subit se répercute sur l'autre nom, et ce, dans les deux sens
un pointeur : une donnée numérique entière (généralement non signée) qui représente l'adresse mémoire à laquelle "on est censé" trouver la donnée du type indiqué, que l'on obtient avec un code proche de Point * lePointeur = & lePoint; // lePointeur est un pointeur auquel on donne l'adresse à laquelle se trouve la donnée lePoint

C'est dans le cadre de ces deux derniers points que l'on constate que l'esperluette représente deux choses totalement différentes en fonction du contexte:

Dans le deuxième cas, nous sommes dans le contexte d'une déclaration (parce que le nom de la donnée est précédée d'une information concernant le type de donnée qu'elle représente), ce qui fait que laReference est ... une référence sur une donnée de type Point

Dans le troisième cas, nous sommes dans le contexte d'un accès, vu que l'on veut assigner l'adresse mémoire à laquelle se trouve la donnée lePoint à une donnée de type "pointeur sur Point" (parce que le nom de la donnée n'est pas précédée du type de donnée qu'elle représente).

C'est donc l'opérateur "address of" (adresse de), qui permet ... de récupérer l'adresse mémoire à laquelle nous trouverons la donnée lePoint à l'exclusion de toute autre (du moins, aussi longtemps que la donnée lePoint existera).

Ces trois cas représentent autant de possibilités de définir ce que l'on appelle de manière générale une "variable". Les mêmes cas pourraient être utilisés avec le mot clé const (ou même le mot clé constexpr) pour désigner des constantes en cas de besoin.

Cependant, l'usage que l'on pourra faire de ces trois données sera différent en fonction du cas choisi parce qu'ils nous permettent de déclarer une donnée comme étant "une valeur", "une référence" ou "un pointeur".

Ensuite, on peut faire la distinction entre "variable" et "paramètre" (ou même "argument"):

Une variable est une donnée que l'on déclare pour "notre usage personnel". Chaque fois que tu as besoin de manipuler une donnée "qui vient de nulle part" au sein d'une fonction, tu déclare une variable (ou une constante)
Un argument désigne la donnée que tu dois impérativement transmettre à la "boite noire" représentée par une fonction (cf l'autre discussion :D) pour qu'elle soit en mesure de faire le taf que l'on attend de sa part, du point de vue de l'utilisateur de la fonction.
Un paramètre désigne la donnée qui a été transmise à la "boite noire" représentée par une fonction pour qu'elle soit en mesure de faire le taf que l'on attends de sa part, du point de vue du développeur de la fonction (du point de vue de la personne qui écrit le code de la fonction, uniquement le temps qu'il le fasse et qu'il puisse s'assurer que la fonction fait ce que l'on en attend)

Les termes "paramètre" et "argument" vont tous les deux avoir pour résultat, au niveau de la fonction qui est appelée, de créer "une variable" dont le type correspond au type de la donnée transmises / à transmettre et dont le nom sera celui du paramètre / de l'argument considéré.

La seule chose, c'est que la fonction appelée n'est pas capable de définir cette donnée "par elle-même" -- et qui pourrait d'ailleurs changer d'un appel à l'autre -- et que l'on doit donc demander à l'utilisateur de la fonction de nous la transmettre, entre autre, pour garantir que les valeurs représentées par cette donnée correspondent aux valeurs "susceptibles d'intéresser l'utilisateur".