Discussion :

[Gibra]

Bonjour à tous.

Après avoir parcouru un peu le forum et le reste de l'internet, j'ai trouvé diverses informations concernant mon souci, mais rien de compréhensible ou fonctionnel.

Il s'agit d'un devoir d'algorithmique dont voici l'énoncé

Ecrire une fonction en C qui reçoit un nombre entier (ex: 13) et retourne un tableau de caractères représentant la valeur binaire de ce nombre (ex: 1101).

Ma fonction doit donc prendre un entier en paramètre et utiliser la division modulaire pour compléter une chaîne de caractère (qui sera ensuite inversée, sans quoi le résultat sera faux) puis retournera cette valeur.

Cependant, après avoir procédé à l'implémentation, je ne parviens toujours pas au bout de mes peines. Mon erreur doit probablement venir de la façon dont je manipule ma chaîne de caractère.

Pourrait-on m'indiquer mon erreur et le pourquoi de son dysfonctionnement ?

Voici le code que j'utilise (celui que j'ai actuellement, j'ai testé plein de choses mais rien de concluant). Il n'y a pas l'inversion de la chaîne de caractère dedans.

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
26
27
28
29
30
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
char* convertToBinary(int nb)
{
    char *bin = (char*)malloc(sizeof(char)*8); //Admettons que je n'utilise que des chiffres codés sur 1 octet
    int i = 0;
 
    //Le reste de la division sera utilisé pour compléter le binaire. Puis on prends le résultat entier de la division pour continuer la conversion
    for(i = nb; i > 0; i /= 2)
    {
        if(i % 2)
            *bin += "1";
        else
            *bin += "0";
    }
 
    return bin; //On retourne la chaîne de caractère
}
 
int main()
{
    int number = NULL;
    scanf("%d", &number);
    printf("%s\n", convertToBinary(number));
 
    return 0;
}

J'ai également tenté sans succès d'utiliser strcpy et strcat, voire la combinaison des deux. Sans succès

Ce code compile mais retourne des valeurs étranges. Par exemple, si j'entre le nombre 13 (comme dans la donnée), j'obtiens comme résultat : ↕↨i↕↨i

Notez que ce résultat change à chaque exécution, malgré le fait que j'entre toujours le nombre 13.

Merci pour vos éclaircissements.

[Obsidian]

Bonjour,

Le résultat que tu obtiens correspond à l'état indéterminé de la mémoire que tu alloues.

Ensuite, le C ne gère pas à proprement parler de format « chaîne de caractères » ou « string » comme certains langages de plus haut niveau. Tu ne peux donc pas lui demander d'ajouter un caractère avec +=. Il faut en fait les considérer exactement comme ce qu'elles sont : des tableaux de caractères individuels. Et donc, aller placer chaque caractère à la bonne place dans le tableau.

Par contre, ça aurait dû fonctionner avec strcat(). Si tu disposes encore du code qui l'utilise, essaie d'ajouter *bin='\0'; juste après le malloc().

Si ça ne fonctionne pas, on te mènera vers la solution la plus courante pour cet exercice somme toutes très classique.

[Gibra]

En effet, cela fonctionne en initialisant comme tu me l'as recommandé : *bin = '\0' et en utilisant ensuite strcat().

Par contre j'avais tenté un code sans l'allocation de mémoire malloc() en initialisant comme suit : char* bin = "";. J'avais cru lire que dans ce genre de cas, les compilateurs géraient l'ajout automatique du caractère de fin de chaîne '\0'. Cependant, cela n'a pas mieux fonctionné.

Aurais-tu des précisions à ce sujet ?

Sinon, je marque le problème comme résolu. Merci de ta proposition. il ne me reste plus qu'à retourner mon tableau de caractère, mais cela ne devrait pas poser de problèmes

Merci beaucoup pour ta réponse rapide et efficace

[Obsidian]

Par contre j'avais tenté un code sans l'allocation de mémoire malloc() en initialisant comme suit : char* bin = "";. J'avais cru lire que dans ce genre de cas, les compilateurs géraient l'ajout automatique du caractère de fin de chaîne '\0'. Cependant, cela n'a pas mieux fonctionné.

Aurais-tu des précisions à ce sujet ?

Commençons avec un détail :

• Les apostrophes 'A' sont une expression de type char exactement. Ils contiennent donc un et un seul caractère et l'expression ainsi évaluée renvoie sa valeur numérique (donc son code ASCII) ;
• Les guillemets "A" servent à définir une chaîne de caractères. Sa longueur est arbitraire et peut même être nulle, mais elle se termine effectivement toujours par un caractère nul, marqueur de fin de chaîne. L'expression elle-même est de type char *.

Maintenant, les chaînes de caractères n'existent pas à proprement parler en C parce que contrairement aux types numériques qui sont fixes et déterministes, une chaîne de caractères est un objet de taille variable, donc nécessitant des infrastructures d'allocation et réallocation d'espace, et qui doit contenir en plus des méta-données (sa taille ou, à tout le moins, le marqueur de fin de chaîne). Et tous ces mécanismes doivent en plus opérer à l'exécution.

Le programmeur C travaille donc « en dessous » de cette couche, c'est-à-dire que c'est lui qui va gérer explicitement l'allocation de l'espace mémoire nécessaire.

Maintenant, lorsque l'on travaille avec des chaînes de caractères en C, on utilise des « char * », c'est-à-dire des pointeurs sur un caractère. Un pointeur est une variable qui contient une adresse mémoire, et plus précisément l'adresse d'une instance d'un type connu (sauf si void). En l'occurrence, ce pointeur indique le premier caractère de la chaîne. Les fonctions qui l'utilisent sont alors capables d'aller chercher les suivants.

Quand tu utilises des guillemets, tu définis une chaîne constante, écrite « en dur » dans le code. À la compilation, elle va se retrouver soit directement dans le code compilé lui-même, soit dans la section .rodata de ton exécutable, mais dans tous les cas dans une section en lecture seule. L'expression elle-même est évaluée comme un char *, c'est-à-dire que l'expression vaut l'emplacement où la chaîne se trouve.

La subtilité se trouve ici :

• Si tu écris char bin[] = "chaine";, tu définis un tableau de caractères et la chaîne que tu lui passes servira de données initiales pour le remplir ;
• Si tu écris char * bin = "chaine";, tu définis un « pointeur vers un char » qui, par défaut, pointera la chaîne en question, qui elle se trouve en mémoire en lecture seule.

Note bien que dans le deuxième cas, aucun espace mémoire n'est réservé à l'exécution pour la chaîne de caractères. Si tu t'es retrouvé dans le second cas, alors ton programme n'a pas marché parce tes caractères se retrouvait en read-only et étaient donc perdus.

Note également que dans le premier cas, je n'ai précisé aucune taille au tableau qui, dans ce cas, adopte automatiquement la taille nécessaire pour stocker la chaîne. Si tu passes une chaîne vide, le tableau ne contiendra que le terminateur et ne sera pas plus grand qu'un caractère. Tu ne pourras donc rien stocker dedans.

Sinon, je marque le problème comme résolu. Merci de ta proposition. il ne me reste plus qu'à retourner mon tableau de caractère, mais cela ne devrait pas poser de problèmes

En fait, si : tu risques une fuite de mémoire. Mais peu importe pour le moment.

Merci beaucoup pour ta réponse rapide et efficace

À ton service.