surcharge des opérateurs

Version imprimable

Je suis débutant (j'ai commencé en 2007) en c++. Mon problème est : J'aimerai pouvoir ecrire un truc du genre "montype = int".

voici un petit example:
Code:

1 2 3 4 5 6 7 8 9 10 11 struct entier { int n; void operator=(int); }; void operator=(int a) {entier.n=a; }; main() {entier aze; aze = 3; //sinon, ça marche pas ! //alors que j'aimerai que aze soit déclaré : entier aze=3;:cry: };

29/05/2008, 13h57
loicounet

je sais pas ce que vous en pensez mais je trouve ce code un peu "crado":mouarf:

tu devrais peut être revoir ta conception, un truc simple serait de créer une classe MonType avec en attribut ton entier et redéfinir l'opérateur =...
29/05/2008, 14h09
stillman
Ce que tu cherches à faire en faisant

Code:

Entier aze = 3;

n'est pas une affectation mais une initialisation (grosso modo, l'affectation se fait en même temps que la déclaration). Cette écriture est donc équivalente à celle-ci :

Code:

Entier aze(3);

Il faut donc que tu définisses un constructeur prenant en paramètre un int, et le tour est joué.

Pour ta classe, je te conseillerais d'écrire également un constructeur de copie, afin de pouvoir écrire quelque chose comme ça :
Code:

1 2 Entier a = 3; Entier b = a;
et un opérateur d'affectation prenant un Entier comme membre droit, pour pouvoir faire :
Code:

1 2 3 Entier a = 5; Entier b = 3; a = b;
29/05/2008, 15h38
JolyLoic

Citation:

Envoyé par stillman

Pour ta classe, je te conseillerais d'écrire également un constructeur de copie, afin de pouvoir écrire quelque chose comme ça :
[...]
et un opérateur d'affectation prenant un Entier comme membre droit, pour pouvoir faire :

En l'occurrence, dans sa classe, les constructeur par copie et opérateur d'affectation générés par défaut font le bon travail. Pas l peine donc de les redéfinir.
29/05/2008, 15h39
Arson

stillman:"Il faut donc que tu définisses un constructeur prenant en paramètre un int, et le tour est joué."

Justement, c'est celà que je ne connais pas. Je sais pas le définir. la notion de surcharge d'opérateur est l'une des choses que je ne domine pas encore.
Pourais-tu me donner la définition de ce constructeur ?

réponse dernière question

:salut:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// défintion de la classe 
class entier
{ 
protected:
	int n;
 
public:
 
	// accesseurs de l'attribut n
	void setN(int v) {n = v;};
	int getN() { return n;};
 
	// contructeur
	entier(int v = 0){ n=v;};// par défaut 
};
 
// le main
int main()
{
	entier monEntier(4);
	return 0;
}

A+,
Agamitsudo

29/05/2008, 17h41
stillman

Citation:

Envoyé par JolyLoic

En l'occurrence, dans sa classe, les constructeur par copie et opérateur d'affectation générés par défaut font le bon travail. Pas l peine donc de les redéfinir.

Effectivement, j'avais oublié que le compilateur créait par défaut une copie "naÏve", qui convient très bien ici.
29/05/2008, 20h55
Arson

Je tiens à remercier tous ce qui ont participé. Grâce à vous je peux maintenant continuer mon proget. En fait, je voulai créer un type "bin" (0,1,10,11,100...).
bin a = 10101;a++;cout<<"a = "<<a; //sortie: a = 10110

Le code dont AgamitSudo a posté marche trés bien mais je ne comprend pas
très bien : D'après ce que je pense, on a surchargé opérateur "=" alors que ton code ne présente aucun signe de surcharge (du genre...operato=(int)).

J'aimerai bien aussi (si possible) savoir comment avoir le même résultat mais en utilisant operator= parce que je crois que j'en aurais besoin lorsque je désire incrémenter a (ecrire a++).
29/05/2008, 21h31
JolyLoic
C'est ce que stillmann a tenté de t'expliquer.

Quand tu écris
Code:

1 2 3 entier a; a = 1; entier b = 1;
Tu as écrit deux choses très différentes. Dans le premier cas, tu as construit un objet de type "entier" avec le constructeur par défaut. Puis tu as appelé l'opérateur= sur ton objet pour lui affecter une autre valeur.

Dans le second cas, tu as construit un objet de type "entier" avec un constructeur qui accepte un int en paramètre. Il n'y a pas du tout d'opératuer = dans la ligne concernant b.

Ensuite, sans que tu fasses rien, le compilateur défini automatiquement des fonctions à ta place, dont l'opérateur=. Dans ton cas, cette version fait ce qu'il faut, donc pas besoin de faire quoi que ce soit : Même sans rien faire, ta classe a déjà un opérateur =.

Je reprends le code (pédantisme, quand tu nous tiens...)

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
// défintion de la classe 
class entier
{ 
// non, pas protected. protected ne protège rien.
private:
	int n;
 
public:
// pas de set, parce que ça ne sert à rien ici 
// (l'opérateur= s'en charge fort bien)
	// accesseurs de l'attribut n
	// void setN(int v) {n = v;};
// le get() ne modifiant pas l'objet, on le définit en méthode const
	int get() const { return n;};
 
// on survit à la tentation de définir un opérateur de cast vers int
// pour se sauvegarder des cast implicites qui peuvent poser plus
// de problème que nous donner de solution. 
 
	// contructeur
	// entier(int v = 0){ n=v;};// par défaut
// utiliser une liste d'initialiseur plutôt:
        entier(int v = 0) : n(v) { }
 
// manque l'opérateur d'assignation
        entier& operator=(int v)
        {
           n = v;
// on retourne l'objet pour pouvoir chainer les appels si besoin.
           return *this;
        }
};
 
// le main
int main()
{
        entier e1;    // ok
	entier e2(4); // ok
 
        e1 = 5;       // ok
        e2 = e1;      // ok aussi, plus par chance que par réel désir...
 
	return 0;
}