Discussion :

[digofwall]

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 :

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

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

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

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

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

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 :

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

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 :

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

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

[3DArchi]

Bonjour,
Il faut comprendre que ce sont 2 fonctions différentes :

Code :

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

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 :

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

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
}

[digofwall]

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 :

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

[digofwall]

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 :

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

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

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

[Médinoc]

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 C++ :

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

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 C++ :

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