contructeur de copie et surcharge d opérateur

Version imprimable

bonjour,
Comment puis je définir le constructeur de copie avec la surcharge d'opérateur et l'utilisation du pointeur this.

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
 
#include <iostream>
 
using namespace std;
 
class Compteur{
    public:
        Compteur();
        Compteur(const Compteur&);
        ~Compteur(){}
        int GetVal() const {return saVal;}
        void setVal(int x){saVal = x;}
        void Increment(){++saVal;}
        const Compteur& operator++();
 
    private:
        int saVal;
};
 
Compteur::Compteur():saVal(0){};
 
 
const Compteur& Compteur::operator++(){
    ++saVal;
    return *this;
}
 
Compteur::Compteur(const Compteur&){
    cout << "Constructeur de copie !" << endl;
    ++*this;
}
 
int main()
{
    Compteur i;
    cout << "La valeur de i est " << i.GetVal() << endl;
    i.Increment();
    cout << "La valeur de i est " << i.GetVal() << endl;
    ++i;
    cout << "La valeur de i est " << i.GetVal() << endl;
    Compteur a = ++i;
    cout << "La valeur de a " << a.GetVal();
    cout << " et de i " << i.GetVal() << endl;
    return 0;
}

Au passage dans la constructeur de copie je me retrouve avec un comportement indéfini.

Merci

21/08/2010, 16h20
NoIdea
C'est normal : il n'y a nul part ou tu indique la valeur de départ de ton int dans le constructeur de copie. Si tu veux que sa marche, je pense que
Code:

1 2 3 4 5 Compteur::Compteur(const Compteur& c){ cout << "Constructeur de copie !" << endl; saVal=c.saVal; ++(*this); }
En espérant que sa marche...
21/08/2010, 16h59
burndev

dans ce cas la, je supprime le pointeur.
Je pensais que lors de la copie 'this' passait a toute les fonctions membres.
La copie fonctionne
21/08/2010, 23h26
koala01
Salut,

De prime abord, je dirais que tu n'a strictement rien à faire ni au niveau du constructeur par copie, ni à celui de l'opérateur d'affectation ni à celui du destructeur:

Comme tu ne manipule absolument aucun pointeur à l'intérieur de la classe, tu peux laisser le compilateur générer automatiquement ces trois fonctions particulières;)

Pour information, l'utilisation de this est implicite dans les fonctions membres (pour tout ce qui est effectivement accessible depuis l'objet, comme les membres et fonctions membre de la classe), et tu peux donc le laisser purement et simplement tomber (sauf cas particuliers qu'il serait trop long d'évoquer ici ;))

Ceci dit, il ne me semble absolument pas utile d'exposer le mutateur "setval" dans le sens où, en toute logique, tu définis une bonne fois pour toute la valeur de départ de ton compteur, puis qu'elle évoluera en fonction des opérations que tu effectuera dessus ;)

Enfin, je me demande s'il est vraiment utile d'avoir un opérateur ++ et une fonction increment dans la même classe.

Pour quand même te permettre de comprendre le constructeur par copie, il faut comprendre que c'est une fonction particulière qui ne renvoie strictement rien (même pas void).

Si tu voulais effectivement définir toi même ce constructeur, il faudrait déjà veiller à... passer réellement un objet du type adéquat comme paramètre.

Il prendrait alors la forme simple de:

Code:

Compteur::Compteur(Compteur const & c):saVal(c.saVal){}

C'est l'opérateur d'affectation qui renvoie une référence sur l'objet en cours.

Etant donné que l'on ne travaille avec aucun pointeur, il prendrait la forme de
Code:

1 2 3 4 5 Compteur & Compteur::operator = (Compteur const & c) { saVal = c.saVal; return *this; }
(si ta classe compteur venait à manipuler un pointeur en interne, l'idiome copy and swap serait la solution idéale et la plus sécurisante ;))

Je tiens à rappeler une fois de plus qu'il ne sert à rien d'implémenter ces deux fonctions (opérateur d'affectation et constructeur par copie), car elles font toutes deux partie du Big Four: les quatres fonctions qui sont automatiquement implémentées pour toute structure et toute classe par le compilateur si le développeur ne les déclare pas lui-même ;)

Le code que je viens de donner pour celles-ci est, en définitive, fort proche de ce que le compilateur aurait lui-même implémenté, dés lors, pourquoi se fatiguer à le faire soi-même :question:

Si je l'ai donné, c'est essentiellement pour te permettre de comprendre ce qu'il faudrait faire ;)
22/08/2010, 22h14
burndev

bonsoir,

Merci pour cette réponse koala1, qui est toujours aussi bien détaillé.
Le morceau de code posé dans le topic est le résultat des divers tests de ma formation et j'aurais du peut être le préciser.

Le principal pour moi était de comprendre le rôle et le résultat avec le constructeur de copie et la surcharge d'opérateur.

merci