probléme surcharge operator+

Version imprimable

bonjour

je m'entraine sur la surcharge des operateur+ , j'ai crée un petit programme pour 'mentrainer , il se trouveee que je n'arrive pas a faire quelque chose

exempleee j'ai objet 1+ objet 2 la c'est ok

mais si je fais 10 + objet la ça ne va plus

je vous donne mon code :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
.h :
 
#ifndef DEF_Pc
#define DEF_Pc
 
class Pc
{
    public:
 
    Pc(int ram = 0, int capacite = 0, int proc = 0);
    Pc operator+(const Pc &pc);
    void afficher();
 
    private:
 
    int m_ram;
    int m_capacite;
    int m_proc;
};
 
#endif

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
 
pc:
 
#include <iostream>
#include "op.h"
 
using namespace std;
 
Pc::Pc(int ram, int capacite, int proc) : m_ram(ram), m_capacite(capacite), m_proc(proc)
{
}
 
Pc Pc::operator+(const Pc &pc)
{
    int ram = m_ram;
    int capacite = m_capacite;
    int proc = m_proc;
 
 
    proc += pc.m_proc; 
 
 
 
    capacite += pc.m_capacite;
 
 
    // 3 : ajout des heures
    ram += pc.m_ram;
 
    // Création de l'objet resultat et retour
    Pc resultat(ram,capacite,proc);
    return resultat;
}
 
void Pc::afficher()
{
    cout << m_ram << "ram " << m_capacite << "capacite " << m_proc << " processeur " << endl;
	cout<<endl;
}

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
main :
 
#include <iostream>
#include "op.h"
 
using namespace std;
 
int main()
{
    Pc pc1(2, 250, 29), pc2(2, 20, 70);
    Pc resultat;
 
    pc1.afficher();
 
    pc2.afficher();
 
    resultat = pc1 + pc2;
 
 
    resultat.afficher();
 
 
    return 0;
}

je souhaiterai donc faire 10 + pc2 par exemple , ( c'est juste pour savoirrr le faire car dans le prog ça sert pas a grand chose .

mrci pour votre aide

02/11/2009, 09h22
Kromagg
Bonjour digofwall

Si tu regardes bien ta surcharge d'opérateur tu verras qu'elle ne peut marcher qu'avec un objet de type Pc
Code:

1 2 Pc operator+(const Pc &pc);
Si tu veux en plus utiliser la surcharge avec un entier ou tout autre type primitif du langage :
Code:

1 2 3 4 5 Pc operator +(int monEntier); Pc operator +(float monFloat); Pc operator +(double monDouble); ...
Tu peux aussi utiliser les opérateurs d'incrémentation et de décrémentation :
Code:

1 2 3 4 Pc operator ++(void); // Opérateur préfixé Pc operator ++(const &Pc); // Opérateur postfixé // Idem pour l'opérateur --
Attention toute fois avec l'opérateur postfixé, il y a:
- copie locale de l'objet
- renvoie de la copie de l'objet (impossible de renvoyer une référence)
Ce qui pose un problème de surcoût non négligeable en fonction de la taille de l'objet). Il est donc préférable d'utilisez la version préfixée, sauf nécessité absolue.

Un petit lien sur la surcharge de fonctions et d'opérateurs
http://lipm-bioinfo.toulouse.inra.fr/c++/surch.html

Kromagg
02/11/2009, 10h29
3DArchi
Bonjour,
Il faut comprendre que ce sont 2 fonctions différentes :
Code:

1 2 3 4 struct A; A a; a + 1; // (1) 1 + a; // (2)
(1) est une méthode qui prend comme premier argument un A et comme second un int
(2) est une méthode qui prend comme premier argument un int et comme second un A
Il te faut donc définir les 2 signatures :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 struct A { int m; int operator+(int i_)const // (1) { return m + i_; } }; int operator+(int i_, A const&a) // (2) { return a+i_; // si + reste commutatif }

mrci pour vos réponses j'ai bien compris le principe . par contre j'ai essayer la depuiss je n'ai sais combiens de temps et j'y arriveee pas :/

a ce niveau ici :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 Pc Pc::operator+(int i,const &pc) { int ram = m_ram; int capacite = m_capacite; int proc = m_proc; i+proc = pc.m_proc; i+capacite += pc.m_capacite; i+ ram = pc.m_ram; Pc resultat(ram,capacite,proc); return resultat; }
je patoge ici je ne sais pas trop comment faire dans ma situation

la j'ai plein d'erreurs

j'ai reusssiii en utilisant friend , mrci pour votre aide , j'éspere que ce que j'ai fais est " possible "

je vous mets mon résultat :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#ifndef DEF_Pc
#define DEF_Pc
 
class Pc
{
    public:
 
    Pc(int r=0,int c=0,int p=0);
    friend  Pc operator+(int i,Pc pc);
    void afficher();
	friend Pc operator+(Pc pc1,Pc pc2);
 
 
    private:
 
    int ram;
    int capacite;
    int proc;
};

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
#include <iostream>
#include "op.h"
 
using namespace std;
 
int main()
{
    Pc pc1(2, 250, 29), pc2(2, 20, 70);
 
    pc1.afficher();
    pc2.afficher();
    Pc res;
	res=10+pc1;
	res.afficher();
	res=pc1+pc2;
	res.afficher();
 
 
 
 
 
 
    return 0;
}

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
#include <iostream>
#include "op.h"
 
using namespace std;
 
Pc::Pc(int r,int c,int p){
	ram=r;
	capacite=c;
	proc=p;
}
 
 
void Pc::afficher()
{
    cout << ram << "ram " << capacite << "capacite " << proc << " processeur " << endl;
	cout<<endl;
}
 
 
Pc operator+(int i,Pc pc){
	Pc res;
	res.ram=i+pc.ram;
	res.capacite=pc.capacite;
	return res;
}
 
Pc operator+(Pc pc1,Pc pc2)
{
	Pc res;
	res.ram=pc1.ram+pc2.ram;
	res.capacite=pc1.capacite+pc2.capacite;
	res.proc=pc1.proc+pc2.proc;
	return res;
}

C'est bien. Avant, tu semblais confondre les opérateurs + et +=.

Si tu veux éviter d'avoir à faire du friend, je te conseillerais ceci:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Pc
{
public:
	Pc(int r=0,int c=0,int p=0);
	void afficher() const;
 
	Pc& operator+=(Pc const& right);
	Pc& operator+=(int i);
 
private:
 
	int ram;
	int capacite;
	int proc;
};

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
#include <iostream>
#include "op.h"
 
using namespace std;
 
Pc::Pc(int r,int c,int p)
 : ram(r), capacite(c), proc(p)
{
}
 
 
void Pc::afficher() const
{
    cout << ram << "ram " << capacite << "capacite " << proc << " processeur " << endl;
	cout<<endl;
}
 
Pc& Pc::operator+=(Pc const& right)
{
	ram += right.ram;
	capacite += right.capacite;
	proc += ram.proc;
	return *this;
}
 
Pc& Pc::operator+=(int i)
{
	ram += i;
	return *this;
}
 
Pc operator+(Pc const& pc1, Pc const& pc2)
{
	Pc res(pc1);
	res += pc2;
	return res;
}
 
 
Pc operator+(Pc const& pc, int i){
	Pc res(pc);
	res += i;
	return res;
}
Pc operator+(int i, Pc const& pc){
	Pc res(pc);
	res += i;
	return res;
}