Discussion :

[candidson]

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!

[FabaCoeur]

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

[droggo]

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.

[FabaCoeur]

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 !

[candidson]

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

[candidson]

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();
}

[nicroman]

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 :

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

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

[candidson]

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