Discussion :

[aimenux]

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
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
134
135
136
137
138
139
140
141
142
143
144
#include <iostream>
using namespace std;
 
class complexe
{
    int reel,imag;
    static int nombre;
    public :
    static int getValue();
    complexe(int r=0,int i=0):reel(r),imag(i) {nombre++;}
    ~complexe() {nombre--;}
    int& getReel() {return reel;}
    int& getImag() {return imag;}
    void affiche();
    friend complexe operator+ (complexe c1,complexe c2);
    complexe operator= (complexe c);
    complexe operator+= (complexe c);
    friend int operator== (complexe c1,complexe c2);
    friend istream& operator>> (istream& i,complexe& c);
    friend ostream& operator<< (ostream& o,complexe& c);
    int& operator[] (int i);
    complexe operator++ ();
    complexe operator++ (int);
    operator int();
};
 
int complexe::nombre = 0;
 
int complexe::getValue()
{
    return nombre;
}
 
void complexe::affiche()
{
    cout <<reel<<"+i"<<imag<<endl;
}
 
complexe operator+ (complexe c1,complexe c2)
{
    complexe res;
    res.getReel() = c1.getReel() + c2.getReel();
    res.getImag() = c1.getImag() + c2.getImag();
    return(res);
}
 
complexe complexe::operator= (complexe c)
{
    if(this != &c)
    {
        reel = c.reel;
        imag = c.imag;
    }
    return(*this);
}
 
complexe complexe::operator+= (complexe c)
{
    reel += c.reel;
    imag += c.imag;
    return(*this);
}
 
int operator== (complexe c1,complexe c2)
{
    if(c1.getReel() == c2.getReel() && c1.getImag() == c2.getImag())
        return 1;
    return 0;
}
 
istream& operator>> (istream& i,complexe& c)
{
    cout<<"Partie reel :\n";
    i>>c.getReel();
    cout<<"Partie imaginaire :\n";
    i>>c.getImag();
    return i;
}
 
ostream& operator<< (ostream& o,complexe& c)
{
    o<<c.getReel()<<"+i"<<c.getImag()<<endl;
    return o;
}
 
int& complexe::operator[] (int i)
{
    if(i==1)
        return(reel);
    return(imag);
}
 
complexe complexe::operator++ ()
{
    ++reel;
    ++imag;
    return(*this);
}
 
complexe complexe::operator++ (int i)
{
    complexe tmp = *this;
    tmp.reel++;
    tmp.imag++;
    return(tmp);
}
 
complexe::operator int()
{
    return reel;
}
 
/********************************/
int main()
{
    complexe* c1 = new complexe(2,8);
    cout << complexe::getValue() << endl;
    complexe* c2 = new complexe(1,3);
    cout << complexe::getValue() << endl;
    complexe* c3 = new complexe(1,3);
    cout << complexe::getValue() << endl;
    *c3 = *c1 + *c2;
    cout << complexe::getValue() << endl;
    cout << *c1 << *c2 << *c3;
    delete c1;
    delete c2;
    delete c3;
    cout << complexe::getValue() << endl;
    return 0;
}
/********************************/
 
 
/**** ECRAN EXECUTION ***/
 
$ ./test
1
2
3
0
2+i8
1+i3
3+i11
-3

==========

[aimenux]

PQ avant de detruire les pointeurs , le nombre d'instances passe à zero ???

[screetch]

parce qu'il existe un autre moyen de construire des complexes, c'est de les copier a partir d'un autre complexe. ce code est généré par le compilateur si tu ne le fournis pas. et comme c'est un autre moyen de construire des complexes, il devrait aussi incrementer le nombre d'instances.

[aimenux]

parce qu'il existe un autre moyen de construire des complexes, c'est de les copier a partir d'un autre complexe. ce code est généré par le compilateur si tu ne le fournis pas. et comme c'est un autre moyen de construire des complexes, il devrait aussi incrementer le nombre d'instances.

oui il y en a un autre , celui du constructeur par copie , mais là ! ds mon programme il n'ya pas appel au constructeur par copie, j'appelle le constructeur complexe(int,int) à chaque fois et cé ça qui est bizarre ! le nombre est 3 et aprés avant de liberer la memoire ca passe à 0!

[coyotte507]

Salut,

en fait lorsque dans tes opérateurs + et = tu ne passes pas par référence, le constructeur par copie est appelé.

Voilà avec les références:

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
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
134
135
136
137
138
139
#include <iostream>
 
using namespace std;
 
class complexe
{
        int reel,imag;
        static int nombre;
    public :
        static int getValue();
        complexe(int r=0,int i=0):reel(r),imag(i) {
            nombre++;
        }
        ~complexe() {
            nombre--;
        }
        int& getReel() {
            return reel;
        }
        int& getImag() {
            return imag;
        }
        void affiche();
        friend complexe operator+ (complexe& c1,complexe& c2);
        complexe& operator= (complexe c);
        complexe& operator+= (complexe c);
        friend int operator== (complexe &c1,complexe &c2);
        friend istream& operator>> (istream& i,complexe& c);
        friend ostream& operator<< (ostream& o,complexe& c);
        int& operator[] (int i);
        complexe operator++ ();
        complexe operator++ (int);
        operator int();
};
 
int complexe::nombre = 0;
 
int complexe::getValue()
{
    return nombre;
}
 
void complexe::affiche()
{
    cout <<reel<<"+i"<<imag<<endl;
}
 
complexe operator+ (complexe& c1,complexe &c2)
{
    complexe res;
    res.getReel() = c1.getReel() + c2.getReel();
    res.getImag() = c1.getImag() + c2.getImag();
    return(res);
}
 
complexe& complexe::operator= (complexe c)
{
    if (this != &c)
    {
        reel = c.reel;
        imag = c.imag;
    }
    return(*this);
}
 
complexe& complexe::operator+= (complexe c)
{
    reel += c.reel;
    imag += c.imag;
    return(*this);
}
 
int operator== (complexe& c1,complexe& c2)
{
    if (c1.getReel() == c2.getReel() && c1.getImag() == c2.getImag())
        return 1;
    return 0;
}
 
istream& operator>> (istream& i,complexe& c)
{
    cout<<"Partie reel :\n";
    i>>c.getReel();
    cout<<"Partie imaginaire :\n";
    i>>c.getImag();
    return i;
}
 
ostream& operator<< (ostream& o,complexe& c)
{
    o<<c.getReel()<<"+i"<<c.getImag()<<endl;
    return o;
}
 
int& complexe::operator[] (int i)
{
    if (i==1)
        return(reel);
    return(imag);
}
 
complexe complexe::operator++ ()
{
    ++reel;
    ++imag;
    return(*this);
}
 
complexe complexe::operator++ (int i)
{
    complexe tmp = *this;
    tmp.reel++;
    tmp.imag++;
    return(tmp);
}
 
complexe::operator int()
{
    return reel;
}
 
/********************************/
int main()
{
    complexe* c1 = new complexe(2,8);
    cout << complexe::getValue() << endl;
    complexe* c2 = new complexe(1,3);
    cout << complexe::getValue() << endl;
    complexe* c3 = new complexe(1,3);
    cout << complexe::getValue() << endl;
    *c3 = *c1 + *c2;
    cout << complexe::getValue() << endl;
    cout << *c1 << *c2 << *c3;
    delete c1;
    delete c2;
    delete c3;
    cout << complexe::getValue() << endl;
    return 0;
}

[manpe]

Je dirai meme plus :

Code :

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

1
2
complexe& operator= (complexe& c);
        complexe& operator+= (complexe& c);

Mais je pense que c'est un simple oubli.
De plus, tu n'as pas surcharge le constructeur de recopie pour qu'il incremente le nombre de complexes, donc voila ce qui se passe :

Code :

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

1
2
3
4
5
6
7
8
 
1. complexe* c1 = new complexe(2,8); 
2. complexe* c2 = new complexe(1,3); 
3. complexe* c3 = new complexe(1,3); 
4. *c3 = *c1 + *c2; 
5. delete c1;
6. delete c2;
7. delete c3;

Lignes 1, 2 et 3 : appel du constructeur, N = 3 a l'issue de ces lignes.
Ligne 4 : Creation de 2 varibales locales pour l'addition et d'1 variable locale pour l'affectation, tout cela utilisant le constructeur de recopie, N ne change pas. A la sortie de l'addition, destruction des 2 variables locales, donc appel du destructeur : N = N-2. A la sortie de l'affectation, une destruction de plus, N = N-1, soit N=0 !
Puis lignes 5, 6 et 7 appel du destructeur surcharge sur les variables de ta fonction main: N=-3 :/

[coyotte507]

Salut,

si ton compiles le code que j'ai posté, vu que tout est passé par référence, tu verras que tout se déroule normalement

Sinon tu as raison, c'est:

Code :

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

1
2
complexe& complexe::operator= (const complexe &c);
complexe& complexe::operator+= (const complexe &c);

(sans le const ça ne passe pas :-/)

[manpe]

Oui oui je sais. Je n'ai peut etre pas ete clair, je commentai le code de aimenux poste au depart.

[aimenux]

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
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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
#include <iostream>
using namespace std;
 
class complexe
{
    int reel,imag;
    static int nombre;
    public :
    static int getValue();
    complexe(int r=0,int i=0):reel(r),imag(i) {cout <<"appel au constructeur 1\n"; nombre++;}
    complexe(const complexe& c):reel(c.reel),imag(c.imag) {cout <<"appel au constructeur 2\n"; nombre++;}
    ~complexe() {cout <<"appel au destructeur\n"; nombre--;}
    int& getReel() {return reel;}
    int& getImag() {return imag;}
    void affiche();
    friend complexe operator+ (complexe& c1,complexe& c2);
    complexe operator= (const complexe& c);
    complexe operator+= (const complexe& c);
    friend int operator== (complexe& c1,complexe& c2);
    friend istream& operator>> (istream& i,complexe& c);
    friend ostream& operator<< (ostream& o,complexe& c);
    int& operator[] (int i);
    complexe operator++ ();
    complexe operator++ (int);
    operator int();
};
 
int complexe::nombre = 0;
 
int complexe::getValue()
{
    return nombre;
}
 
void complexe::affiche()
{
    cout <<reel<<"+i"<<imag<<endl;
}
 
complexe operator+ (complexe& c1,complexe& c2)
{
    complexe res;
    res.getReel() = c1.getReel() + c2.getReel();
    res.getImag() = c1.getImag() + c2.getImag();
    return(res);
}
 
complexe complexe::operator= (const complexe& c)
{
	if(this != &c)
	{
		reel = c.reel;
		imag = c.imag;
	}
	return(*this);
}
 
complexe complexe::operator+= (const complexe& c)
{
    reel += c.reel;
    imag += c.imag;
    return(*this);
}
 
int operator== (complexe& c1,complexe& c2)
{
    if(c1.getReel() == c2.getReel() && c1.getImag() == c2.getImag())
        return 1;
    return 0;
}
 
istream& operator>> (istream& i,complexe& c)
{
    cout<<"Partie reel :\n";
    i>>c.getReel();
    cout<<"Partie imaginaire :\n";
    i>>c.getImag();
    return i;
}
 
ostream& operator<< (ostream& o,complexe& c)
{
    o<<c.getReel()<<"+i"<<c.getImag()<<endl;
    return o;
}
 
int& complexe::operator[] (int i)
{
    if(i==1)
        return(reel);
    return(imag);
}
 
complexe complexe::operator++ ()
{
    ++reel;
    ++imag;
    return(*this);
}
 
complexe complexe::operator++ (int i)
{
    complexe tmp = *this;
    tmp.reel++;
    tmp.imag++;
    return(tmp);
}
 
complexe::operator int()
{
    return reel;
}
 
/********************************/
int main()
{
    complexe* c1 = new complexe(2,8);
    cout << complexe::getValue() << endl;
    complexe* c2 = new complexe(1,3);
    cout << complexe::getValue() << endl;
    complexe* c3 = new complexe(1,3);
    cout << complexe::getValue() << endl;
    *c3 = *c1 + *c2;
    cout << complexe::getValue() << endl;
    cout << *c1 << *c2 << *c3;
    delete c1;
    delete c2;
    delete c3;
    cout << complexe::getValue() << endl;
    return 0;
}
/********************************/
$ ./test
appel au constructeur 1
1
appel au constructeur 1
2
appel au constructeur 1
3
appel au constructeur 1
appel au constructeur 2
appel au destructeur
appel au destructeur
3
2+i8
1+i3
3+i11
appel au destructeur
appel au destructeur
appel au destructeur
0
/********************************/

Je vous remercie manpe et coyotte507 , maintenant je comprends exactement le pb , le constructeur par copie il a été appelé ,
Merci

[coyotte507]

Sinon, pour les opérateurs >> et <<, ça serait bien de mettre le deuxième argument en const

[aimenux]

Sinon, pour les opérateurs >> et <<, ça serait bien de mettre le deuxième argument en const

j'ai essayé de les mettre en const mais j'ai eu cet ecran d'erreurs

Code :

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

1
2
3
4
5
$ g++ complexe.cpp -o test
complexe.cpp: In function `std::istream& operator>>(std::istream&, const complexe&)':
complexe.cpp:75: erreur: passant << const complexe>> comme <<cet>> argument de << int& complexe::getReel() >> 'ecarte les qualificateurs
complexe.cpp:77: erreur: passant << const complexe>> comme <<cet>> argument de << int& complexe::getImag() >> 'ecarte les qualificateurs
complexe.cpp: In function `std::ostream& operator<<(std::ostream&, const complexe&)':

complexe.cpp:83: erreur: passant << const complexe>> comme <<cet>> argument de << int& complexe::getReel() >> 'ecarte les qualificateurs
complexe.cpp:83: erreur: passant << const complexe>> comme <<cet>> argument de << int& complexe::getImag() >> 'ecarte les qualificateurs

[coyotte507]

Ah oui, dans ce cas il faut aussi faire:

Code :

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

1
2
3
4
5
6
7
const int& getReel() const {return reel;}
const int& getImag() const {return imag;}
 
ou alors
 
int getReel() const {return reel;}
int getImag() const {return imag;}

[aimenux]

Ah oui, dans ce cas il faut aussi faire:

Code :

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

1
2
3
4
5
6
7
const int& getReel() const {return reel;}
const int& getImag() const {return imag;}
 
ou alors
 
int getReel() const {return reel;}
int getImag() const {return imag;}

je comprend l'utilité du 2éme const dans const int& getReel() const {return reel;} puisqu'il s'agit d"un objet constant donc il faut appliquer une methode constante mais pour le 1er const je vois pas la signification,

aussi pour nt getReel() const {return reel;} normalement ce n'est pas utile dans mon cas puisque je veux modifier l'attribut reel dans operator+ et donc il me faut une reference ou un pointeur,

[coyotte507]

Salut,

le premier const sert à dire qu'on ne peux pas modifier la référence qu'on passe, car alors la méthode ne pourrait pas être const.

Sinon, pour l'opérateur +, il suffit de faire:

Code :

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

1
2
3
4
complexe res;
res.reel = c1.getReel() + c2.getReel();
res.imag = c1.getImag() + c2.getImag();
return(res);

Enfin, les nombres complexes sont vraiment simples, je doute fort de l'utilité d'un private ici, car il n'y a aucun invariant de classe à respecter...

[aimenux]

j'ai changé la classe comme ça :

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
#include <iostream>
using namespace std;
 
class complexe
{
    int reel,imag;
    static int nombre;
    public :
    static int getValue();
    complexe(int r=0,int i=0):reel(r),imag(i) {cout <<"appel au constructeur 1\n"; nombre++;}
    complexe(const complexe& c):reel(c.reel),imag(c.imag) {cout <<"appel au constructeur 2\n"; nombre++;}
    ~complexe() {cout <<"appel au destructeur\n"; nombre--;}
    const int& getReel() const {return reel;}
    const int& getImag() const {return imag;}
    void affiche();
    friend complexe operator+ (const complexe& c1,const complexe& c2);
    complexe operator= (const complexe& c);
    complexe operator+= (const complexe& c);
    friend int operator== (const complexe& c1,const complexe& c2);
    friend istream& operator>> (istream& i,const complexe& c);
    friend ostream& operator<< (ostream& o,const complexe& c);
    int& operator[] (int i);
    complexe operator++ ();
    complexe operator++ (int);
    operator int();
};

mais j'ai eu les erreurs suivants :

Code :

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

1
2
3
4
$ g++ complexe.cpp -o test
complexe.cpp: In function `complexe operator+(const complexe&, const complexe&)':
complexe.cpp:43: erreur: assignment d'une position en lecture seule
complexe.cpp:44: erreur: assignment d'une position en lecture seule

les lignes correspondantes ds le code sont :

Code :

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

1
2
    res.getReel() = c1.getReel() + c2.getReel();
    res.getImag() = c1.getImag() + c2.getImag();

je veux pas changer mes attributs en public mais je sais pa la solution de mettre mes const et d'utiliser private pour les attributs

[coyotte507]

Resalut,

dans mon post précédent, ces lignes:

Code :

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

1
2
res.reel = c1.getReel() + c2.getReel();
res.imag = c1.getImag() + c2.getImag();

Correspondent à ce que tu as posté. (désolé de ne pas avoir été plus clair)

[aimenux]

Merci coyotte507

ça marche nikel

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
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>
using namespace std;
 
class complexe
{
    int reel,imag;
    static int nombre;
    public :
    static int getValue();
    complexe(int r=0,int i=0):reel(r),imag(i) {cout <<"appel au constructeur 1\n"; nombre++;}
    complexe(const complexe& c):reel(c.reel),imag(c.imag) {cout <<"appel au constructeur 2\n"; nombre++;}
    ~complexe() {cout <<"appel au destructeur\n"; nombre--;}
    int& getReel() {return reel;}
    int& getImag() {return imag;}
    void affiche();
    friend complexe operator+ (const complexe& c1,const complexe& c2);
    complexe operator= (const complexe& c);
    complexe operator+= (const complexe& c);
    friend int operator== (const complexe& c1,const complexe& c2);
    friend istream& operator>> (istream& i,const complexe& c);
    friend ostream& operator<< (ostream& o,const complexe& c);
    int& operator[] (int i);
    complexe operator++ ();
    complexe operator++ (int);
    operator int();
};
 
int complexe::nombre = 0;
 
int complexe::getValue()
{
    return nombre;
}
 
void complexe::affiche()
{
    cout <<reel<<"+i"<<imag<<endl;
}
 
complexe operator+ (const complexe& c1,const complexe& c2)
{
    complexe res;
    res.reel = c1.reel + c2.reel;
    res.imag = c1.imag + c2.imag;
    return(res);
}
 
complexe complexe::operator= (const complexe& c)
{
	if(this != &c)
	{
		reel = c.reel;
		imag = c.imag;
	}
	return(*this);
}
 
complexe complexe::operator+= (const complexe& c)
{
    reel += c.reel;
    imag += c.imag;
    return(*this);
}
 
int operator== (const complexe& c1,const complexe& c2)
{
    if(c1.reel == c2.reel && c1.imag == c2.imag)
        return 1;
    return 0;
}
 
istream& operator>> (istream& i,const complexe& c)
{
    cout<<"Partie reel :\n";
    i>>c.reel;
    cout<<"Partie imaginaire :\n";
    i>>c.imag;
    return i;
}
 
ostream& operator<< (ostream& o,const complexe& c)
{
    o<<c.reel<<"+i"<<c.imag<<endl;
    return o;
}
 
int& complexe::operator[] (int i)
{
    if(i==1)
        return(reel);
    return(imag);
}
 
complexe complexe::operator++ ()
{
    ++reel;
    ++imag;
    return(*this);
}
 
complexe complexe::operator++ (int i)
{
    complexe tmp = *this;
    tmp.reel++;
    tmp.imag++;
    return(tmp);
}
 
complexe::operator int()
{
    return reel;
}
 
/********************************/
int main()
{
    complexe* c1 = new complexe(2,8);
    cout << complexe::getValue() << endl;
    complexe* c2 = new complexe(1,3);
    cout << complexe::getValue() << endl;
    complexe* c3 = new complexe(1,3);
    cout << complexe::getValue() << endl;
    *c3 = *c1 + *c2;
    cout << complexe::getValue() << endl;
    cout << *c1 << *c2 << *c3;
    delete c1;
    delete c2;
    delete c3;
    cout << complexe::getValue() << endl;
    return 0;
}
/********************************/