Soustraction infinie

Messages postés
1
Date d'inscription
mercredi 30 octobre 2019
Statut
Membre
Dernière intervention
30 octobre 2019
-
char *classic_sus_op(char const *str1, char const *str2)
{
    int i = my_strlen(str1) - 1;
    int j = my_strlen(str2) - 1;
    int k = 0;
    int rest = 0;
    char *result = malloc(sizeof(char) * (i + j + 1));
    int dec_i = 0;
    int dec_j = 0;
    int test = 0;

    while (i >= 0 || j >= 0 || rest != 0){
        dec_i = (i >= 0) ? str1[i] - '0' : 0;
        dec_j = (j >= 0) ? str2[j] - '0' : 0;
        test = dec_i - dec_j + rest;
        if (test < 0){
            result[k] = (test + 10) + '0';
            rest = 1;
        }
        if (test >= 0){
            result[k] = test + '0';
            rest = 0;
        }
        k++;
        i--;
        j--;
    }
    result[k] = '\0';
    result = my_revstr(result);
     if (result[0] == '0')
        my_putchar('0');
     else
         my_putstr(result);
     my_putchar('\n');
    return (result);
    free(result);
}

void infin_sus(char *av1, char *av2)
{
    int i = my_getnbr(av1);
    int j = my_getnbr(av2);

    if (i > j){
        classic_sus_op(av1, av2);
    } else {
        my_putchar('-');
        classic_sus_op(av2, av1);
    }
}

int main(int ac, char **av)
{
    infin_sus(av[1], av[2]);
}

Voilà un peu mon code. Mais je ne vois pas pourquoi 1000 - 500 me donne 2050 avec ça...
Afficher la suite 

2 réponses

Meilleure réponse
Messages postés
5266
Date d'inscription
mercredi 15 septembre 2004
Statut
Contributeur
Dernière intervention
8 novembre 2019
817
1
Merci
Salut NemesisX1,

Il y a sans doutes plusieurs problèmes qui créent le bogue que tu constates et qu'on ne peut pas reproduire parce que tu fais appel à des fonctions dans ton code que tu ne fournis pas (et que les contributeurs du forum ne vont pas redévelopper à moins d'être très motivés par ta question), et un problème peut aussi se situer dans ces fonctions.

Pour déboguer ton code, le mieux est que tu utilises un débogueur, qui te permet d'exécuter pas à pas les instructions en inspectant les valeurs de variables et de voir précisément à quel(s) moment(s) ton code ne respecte pas la logique que tu essayes d'implémenter.

Ta boucle while me paraît très compliquée, car tu veux y faire beaucoup de choses en même temps.

Une façon de simplifier les choses, quand tu n'as pas une idée très claire de tes conditions de sortie et de leur interaction, est de partir d'une simple boucle
while (1) { }
et d'intégrer les sorties de la boucle avec des instructions
break;
en identifiant et isolant chaque condition de sortie séparément des autres.

Ton
free(result);
étant placé après ton return, il n'est jamais exécuté et occasionne une fuite mémoire. Ce n'est pas ce qui cause ton bogue, mais tu devrais corriger cela.

Dal

Dire « Merci » 1

Heureux de vous avoir aidé ! Vous nous appréciez ? Donnez votre avis sur nous ! Evaluez CommentCaMarche

CCM 71286 internautes nous ont dit merci ce mois-ci

Tomsuper
Messages postés
1879
Date d'inscription
mardi 24 mai 2011
Statut
Membre
Dernière intervention
8 novembre 2019
265 -
Re NemesisX1,

Comme debugeur, tu as gdb qui fonctionne plutôt bien.

Pour voir si tu as des fuites mémoires, tu peux exécute ton programme avec valgrind

Je te conseille de compilé avec -g3 pour debuger et valgrindé.... oui c'est un verbe.

Je te conseille d'enlever -g3 quand tu n'en n'as plus besoin, car il alourdie l’exécutable.

Cordialement
Tomsuper
Messages postés
1879
Date d'inscription
mardi 24 mai 2011
Statut
Membre
Dernière intervention
8 novembre 2019
265 -
D'un autre coté, faire un free d'une valeur qu'on veut retourné, n'est sans doute pas une bonne option.

Puis, le faite retourné résulte dans son code, ne sert à rien.
[Dal]
Messages postés
5266
Date d'inscription
mercredi 15 septembre 2004
Statut
Contributeur
Dernière intervention
8 novembre 2019
817 -
Mon observation n'était pas que le free devrait être avant le return, mais qu'étant placé après il n''était jamais exécuté.

Du point de la conception, il est maladroit de mélanger les genres. Si le rôle de la fonction est de calculer le résultat d'une soustraction, son rôle ne devrait pas être de l'afficher (sauf éventuellement le temps de déboguer la fonction), car l'affichage va enfermer la fonction dans un usage particulier de celle-ci (demain, ou pourrait souhaiter afficher différemment, via une GUI, sauvegarder le résultat dans un fichier, etc.).

L'exploitation du résultat, y compris l'affichage, devrait être la responsabilité de la fonction appelante, et donc aussi la libération de la mémoire, qui ne peut avoir lieu qu'une fois que l'on sait que l'on n'a plus besoin de cette mémoire allouée par la fonction... et cela, ce n'est pas la fonction elle même qui devrait le présumer.
Commenter la réponse de [Dal]
Messages postés
1879
Date d'inscription
mardi 24 mai 2011
Statut
Membre
Dernière intervention
8 novembre 2019
265
0
Merci
Chère Ionisien,

Vérifies tes appelle à malloc.

A la ligne 17 tu fais un +10 pourquoi ?
Si tu veux passé en valeur absolue, je te conseil de faire un macro au après tes déclaration de .h
Genre #define abs(x) ((x) < 0 ? -(x) : (x))

Essai de mettre des && plutôt que des || dans ton while

Cordialement

Tomsuper
Messages postés
1879
Date d'inscription
mardi 24 mai 2011
Statut
Membre
Dernière intervention
8 novembre 2019
265 -
Ou
abs(x) ((x) < 0 ? (x × -1) : (x))
Ce qui revient au même
Commenter la réponse de Tomsuper