bizare comme programme

Version imprimable

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
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

==========
:tagcode::merci:

28/04/2008, 11h56
aimenux

nombre instances bizarre !

PQ avant de detruire les pointeurs , le nombre d'instances passe à zero :roll: ???
28/04/2008, 12h42
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.
28/04/2008, 13h14
aimenux

Citation:

Envoyé par 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.

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!

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:

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;
}

28/04/2008, 14h37
manpe
Je dirai meme plus :
Code:

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:

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 :/
28/04/2008, 14h41
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:

1 2 complexe& complexe::operator= (const complexe &c); complexe& complexe::operator+= (const complexe &c);
(sans le const ça ne passe pas :-/)
28/04/2008, 14h46
manpe

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

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
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 :D, le constructeur par copie il a été appelé :evilred:,
Merci:mouarf:

28/04/2008, 15h17
coyotte507

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

Citation:

Envoyé par coyotte507

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 :mouarf: mais j'ai eu cet ecran d'erreurs :yaisse2:
Code:

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

:evilred:

Ah oui, dans ce cas il faut aussi faire:

Code:

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;}

28/04/2008, 15h31
aimenux
Citation:
Envoyé par coyotte507

Ah oui, dans ce cas il faut aussi faire:

Code:

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, :oops:

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, ;)
28/04/2008, 15h35
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:

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...

j'ai changé la classe comme ça :

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
#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:

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:

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

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

28/04/2008, 15h47
coyotte507
Resalut,

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

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)

Merci coyotte507 :king:

ça marche nikel :D

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>
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;
}
/********************************/