Surcharge de l'opérateur % de facon iterative

Bonjour,
je suis plus ou moins nouveau en C++ et j'ai un pti probleme. Comment pourrais-je surcharger l'operatuer % de facon iterative et sans utiliser les operateurs %, * et /.
Mon idée est la suivante:
Calcul de i%j:
i > j et j!=0;
calculer i - j et redonner le resultat juska ce ke i<j.
Mais je nariv pa à implementer i - j de facon periodique, cest a dire, i-j de facon repetee.
Merci pour l'aide!

Ton problème relève de l'algorithmique pure, et non pas du C++ il me semble.
Tu devrais te tourner vers le forum approprié, tu auras peut-être plus de chance d'y trouver une réponse.
++

Kua,

Je ne vois pas l'intérêt de ce que tu veux faire, si c'est bien pour remplacer l'opérateur %, comme je l'ai compris d'après ton message. :D

Moi aussi je croyais cela, mais en lisant le post en fait j'ai compris qu'il ne veut pas faire une surcharge, mais simplement calculer un modulo sans utiliser l'opérateur % lui-même.

A moins que moi nan plus je n'ai pas bien compris !

Oui c'est bien ca! Calculer le modulo, sans utiliser %, / et *.

Voilà un peu là où je suis bloqué.
Natural est une classe.



Natural operator%(Natural n1, Natural n2)
{
int modulo(0);

if ( n1 == n2)
{ return modulo = 0;}
else
if(n1.getValue()<n2.getValue())
{ modulo = n2.getValue();}
else

while (n2.getValue()!=0 && n1.getValue()<n2.getValue())
{
modulo = n1.getValue() - n2.getValue();
}





return modulo -= n2.getValue();
}

Je vois pas trop l'interêt à ne pas utiliser / et %... mais bon.... Quant à la multiplication, je vois pas son usage dans un modulo (qui est le reste de la division).

Si c'est pour accélérer l'exécution, à mon avis, c'est peine perdue... un / coûte cher, certe, plus cher qu'un +, re-certe... mais à un moment la boucle while avec ses soustraction, va couter encore plus cher....

Sinon... Si tu y tiens vraiment....

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

Natural operator % (const Natural& n1, const Natural& n2) { if (n1 == n2) return Natural(0);   int v2 = n2.getValue(); if (v2 == 1) return n1; // en espérant qu'on ai un constructeur de recopie.   int modulo = n1.getValue(); // là... ca va couter cher ! while (modulo > v2) modulo -= v2;   return Natural(modulo); }

---

Maintenant on peut optimier un peu de la sorte:

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

Natural operator % (const Natural& n1, const Natural& n2) { if (n1 == n2) return Natural(0);   int value = n2.getValue(); if (value == 1) return n1; // en espérant qu'on ai un constructeur de recopie.     int modulo = n1.getValue();   int value_dec = (value << 3); if (modulo < value_dec) { // ici, on a au maximum 7 boucles..... while (modulo > value) modulo -= value; } else { // si + de 7 boucles, on passe par le modulo codé dans la division... modulo = modulo % value; }   return Natural(modulo); }

---

Voilà! Merci bien nicroman. Ca marche!
Il n'y a vraiment pa grand interet à implementer le code de cette maniere mais c'était la volonté du prof de TP!
J'ai implementé tout le code et il marche! Cool! MErci bien