[operator] Redéfinition d'un Cast

Bonjour,

J'aimerai redéfinir un cast de ma class Monnaie, il me semble que le Cast est considéré comme un operator ?
Comment on s'en sert ?

Ma classe est toute simple, c'est un double + String, et j'aimerai quand je reçoit un nombre quelconque pouvoir le caster en Monnaie. (avec des surcharge int et decimal)

Merci

ça ne fonctionne pas comme ça...

Code:

---

1 2 3 4

public static Monnaie operator (Monnaie(int)) { }

---

Pas tout à fait.

La syntaxe exact de redéfinition du cast explicite c'est :

Code:

---

1 2 3 4 5 6 7 8

public static explicit operator Monnaie(OldType oldTypeValue) { Monnaie newValue; // conversion ici // ...... return newValue; }

---

Cette définition étant à faire dans la classe OldType, et s'utilise ensuite comme un cast :

Code:

---

1 2	OldType myValue; Monnaie monnaieValue = (Monnaie)myValue;

---

Dans le cas, que tu décris, c'est impossible (enfin ... je crois), car il faudrait que tu rajoutes la redéfinition à int.( peut être est ce néanmoins possible en C# 3.0/.Net 3.5, avec les méthodes d'extensions, mais là, il faut demander à plus compétent que moi : j'ignore si les méthodes d'extensions sont applicables aux types valeurs et de plus en redéfinition d'opérateur - allo, les spécialistes ?).

C'est possible, cher BlueDeep :)

Code:

---

1 2 3 4 5 6 7 8 9 10

class Monnaie { private int UnTrucEntier; public Monnaie(int i) { this.UnTrucEntier = i; } public static explicit operator int(Monnaie m) { return m.UnTrucEntier; } public static explicit operator Monnaie(int i) { return new Monnaie(i); } }

---

Merci beaucoup tout les 2 :)

Citation:

---

Envoyé par Guulh

C'est possible, cher BlueDeep :)

---

En effet ....

Je pensais que la surcharge du cast devait être faite dans la classe "émettrice"; je me trompais donc.

J'ai envi de faire des opérations sur ma Monnaie, par exemple une multiplication :

Code:

---

1 2 3 4 5 6 7 8 9

public static Monnaie operator *(Monnaie a, Monnaie b) { return new Monnaie(a.valeur * b.valeur); } public static Monnaie operator *(int a, Monnaie b) { return new Monnaie(a * b.valeur); }

---

Dans un cas :

Code:

---

1 2 3

Monnaie m1 = new Monnaie(6); Monnaie ms = 2 * m2;

---

j'obtiens un résultat (12 € par exemple)

Dans un autre cas :

Code:

---

1 2 3

Monnaie m1 = new Monnaie(6); Monnaie ms = m2 * 2;

---

erreur à la compilation :
L'opérateur '*' ne peut pas être appliqué aux opérandes de type Monnaie et int

Je ne vais quand même pas définir toute les combinaisons pour une multiplication ?!

Monnaie * int
int * Monnaie
Monnaie * double
double * Monnaie
etc...

Comment faire simplement ?

Merci (encore)

Citation:

---

Envoyé par Ticoche

J
Comment faire simplement ?

Merci (encore)

---

Ben, cast justement. C'est pour cela que tu as surchargé le cast, non ?

Code:

---

Monnaie ms = (Monnaie)(((int)m2) * 2);

---

En fait, j'aimerai bien que le Cast ne soit pas fait dans mon code, mais directement dans la Class Monnaie, je m'explique :

Code:

---

1 2 3 4 5 6 7 8 9 10

// Dans le code Monnaie m1 = new Monnaie(valeur);   // Exemple 1 Monnaie m2 = new Monnaie(m1 + 2); // 7,20 € // OU Exemple 2 Monnaie m2 = new Monnaie(2 + m1); // 7,20 € problème   txtTestMonnaie.Text = m2.ToString();

---

Code:

---

1 2 3 4 5 6

// Dans la Class Monnaie public static Monnaie operator +(Monnaie a, int b) { return new Monnaie(a.Valeur + b); }

---

Comment faire, pour éviter de faire :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

// Dans la Class Monnaie public static Monnaie operator +(Monnaie a, int b) { return new Monnaie(a.Valeur + b); } public static Monnaie operator +(int a, Monnaie b) { return new Monnaie(a + b.Valeur); } // etc... (toute les aditions, multiplication, etc... possible)

---

Parce que si je dois définir l'opérateur dans tous les cas ça me donne presque une infinité de combinaison... alors que je veux juste définir 4 opérateurs, donc 4 signes seulement...

Merci

Une question, en passant. Pourquoi voudrais-tu multiplier des euros par des euros ? Déjà que j'ai du mal à voir l'utilité de ta classe Monnaie, je comprends par pourquoi tu voudrais des €² :)

Citation:

---

Envoyé par Guulh

Une question, en passant. Pourquoi voudrais-tu multiplier des euros par des euros ? Déjà que j'ai du mal à voir l'utilité de ta classe Monnaie, je comprends par pourquoi tu voudrais des €² :)

---

C'est pour les pertes exponentielles :P

"Pour chaque euro investi, je perd 1/2 euro" --> la perte s'exprime en euro carré. :mrgreen:

Le principe, c'est que je peux multiplier un nombre avec un Monnaie

Code:

---

1 2 3

Monnaie m1 = new Monnaie(10); Monnaie m = new Monnaie((Monnaie)2 * m1);

---

Comme je multiplie la valeur du Monnaie, l'astuce c'est que je cast mon nombre en Monnaie pour le multiplier, ainsi au lieu de faire
2 € * 10 € => ça fait 2 * 10 = 20 € (on viens de doublé le chiffre d'affaire !)

Si je ne fais pas ça, j'en reviens à mon problème de redéfinir toutes les possibilité de multiplicité :
int * Monnaie
Monnaie * int
double * Monnaie
Monnaie * double
etc...

Si quelqu'un à mieux ?

Pour ce qui est de l'addition, je ferais juste des opérateurs de conversion (implicite ou pas, à voir) depuis la plupart des types de base. Pour pouvoir écrire Monnaie m2 = m + (Monnaie)d, où d est un double. Vu que ta classe rajoute un concept "d'unité" (dans sens de mètre, seconde, ampère, etc.), une syntaxe comme "1€" + 2 n'est pas très rigoureuse, alors que "1€" + créerQuantité(1) est correct.

Pour les multiplications, tu peux je vois pas d'autres solution que de faire autant de couple de fn(type t, Monnaie m) / fn(Monnaie m, type t) que tu veux gérer de types de base. C'est pas super long ni compliqué, non plus, même si c'est pas super esthétique :) Les opérateurs n'ont aucune raison particulière d'être commutatifs, même si on aurait pu imaginer une syntaxe pour qu'ils le soient.

Citation:

---

Envoyé par Guulh

Pour ce qui est de l'addition, je ferais juste des opérateurs de conversion (implicite ou pas, à voir) depuis la plupart des types de base. Pour pouvoir écrire Monnaie m2 = m + (Monnaie)d, où d est un double. Vu que ta classe rajoute un concept "d'unité" (dans sens de mètre, seconde, ampère, etc.), une syntaxe comme "1€" + 2 n'est pas très rigoureuse, alors que "1€" + créerQuantité(1) est correct.

---

Oui

Code:

---

1 2	Monnaie m = new Monnaie((Monnaie)2 * m1);

---

C'est l'écriture barbare pour dire :

Code:

---

1 2	Monnaie m = new Monnaie(new Monnaie(2) * m1);

---

Si j'ai bien compris, tu préfères qu'on utilise la 2ème solution, plus "propre" ?

Citation:

---

Pour les multiplications, tu peux je vois pas d'autres solution que de faire autant de couple de fn(type t, Monnaie m) / fn(Monnaie m, type t) que tu veux gérer de types de base. C'est pas super long ni compliqué, non plus, même si c'est pas super esthétique :)

---

Je vais peut être m'y résoudre... :-(

Citation:

---

Les opérateurs n'ont aucune raison particulière d'être commutatifs, même si on aurait pu imaginer une syntaxe pour qu'ils le soient.

---

Alors ça c'est bien dommage, car on m'a appris que :
1 + 2 <==> 2 + 1
3*5 <==> 5*3
je trouve pas ça cool :cry:

Citation:

---

Envoyé par Ticoche

on m'a appris que :
1 + 2 <==> 2 + 1
3*5 <==> 5*3
je trouve pas ça cool :cry:

---

Peut être, mais ne pas oublier que :

17 % 3 <> 3 % 17
5 / 10 <> 10 / 5
4 - 2 <> 2 - 4

etc .....


donc, comme dit supra, aucune raison pour que les opérateurs soient a priori commutatifs :D

Ok, avec toutes ces infos je vais m'en sortir.

Merci encore pour l'aide :)

Citation:

---

Envoyé par Ticoche

Oui

Code:

---

1 2	Monnaie m = new Monnaie((Monnaie)2 * m1);

---

C'est l'écriture barbare pour dire :

Code:

---

1 2	Monnaie m = new Monnaie(new Monnaie(2) * m1);

---

Si j'ai bien compris, tu préfères qu'on utilise la 2ème solution, plus "propre" ?

---

Euh... non :) Ce qui est correct d'un point de vue physique, c'est m2 = m1 * 15 ou m2 = (new Monnaie(2)) * 15, par exemple. T'es bien d'accord que multiplier des sous par un coef, ça fait des sous ? Ton opérateur * doit renvoyer un objet Monnaie, pas besoin de refaire un new comme tu le fais.