Discussion :

[m0ul3sh0t]

Bonjour,

je souhaite convertir un caractère ascii en un nombre binaire (qui sera sous forme de char *).
J'aurais aimé avoir des conseils pour le faire.
Je pensais d'abord convertir le char en int, faire la conversion, puis retransformer mon binaire en char *.
Est ce qu'il y a une facon plus optimiser pour se faire?
(je n'ai rien codé pour le moment, je réfléchis sur la facon de faire avant de me lancer)

Bonne journée

[DaZumba]

je souhaite convertir un caractère ascii en un nombre binaire (qui sera sous forme de char *).

Ce que tu ecris n'a pas vraiment de sens. Il n'y a aucune conversion a faire. Un char est deja un entier (qui correspond au code ASCII d'un caractere si ta machine utilise l'ASCII). En memoire, les variables sont deja representees en binaire.

[m0ul3sh0t]

ce que je veux dire cest que: 'a' vaut 97 dans la table ascii.
Je veux obtenir 97 en binaire et l'avoir dans un char *

tu vois ce que je veux dire?

[DaZumba]

ce que je veux dire cest que: 'a' vaut 97 dans la table ascii.
Je veux obtenir 97 en binaire et l'avoir dans un char *

Par char *, tu veux dire chaine de caractere ? C'est sprintf() qu'il te faut:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
char a = 'a';
char buffer[20];
...
sprintf(buffer, "%d", a);

[m0ul3sh0t]

en fait je ne veux pas afficher le caractere en binaire mais recuperer sa valeur pour pouvoir la reutiliser par la suite

[DaZumba]

Bon, il faut eclaicir le vocabulaire.
Binaire, c'est une representation en base 2 (des 0 et des 1). Rarement utile.
Un caractere est un entier qui peut avoir les valeurs 0 a 255 (ou -127 a 128 s'il est signe). Ces valeurs sont utilisees pour faire une table de correspondance entre un nombre et un caractere dans un alphabet (par exemple, la table ASCII).
Un char * est un pointeur vers une variable de type char. Une chaine de caractere est un tableau de caracteres termine par '\0'. Le nom de ce tableau est aussi l'adresse du premier element, et a le type char *.

En utilisant le vocabulaire ci-dessus, explique ce que tu veux faire exactement.

[pythéas]

sprintf(buffer, "%d", a);
ne sert pas à afficher a mais à renvoyer ce que tu sembles vouloir dans buffer

[m0ul3sh0t]

A partir d'un char que je recois en parametre, je veux obtenir sa valeur en binaire pour pouvoir la reutiliser par la suite

est ce que jai ete un peu plus clair?

[=o0 MOH =0o=]

Comme l'a dit DaZumba, en mémoire toutes les données sont déjà représentées en binaire.
Donc je pense que tu veux récupérer cette représentation binaire de ton caractère?
Essaye un truc du genre:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
char caractere = 'A';
char * ptCaractere;
int valeurMemoire = 0;
//ton pointeur pointe sur l'adresse de l'entier qui contiendra la valeur 'binaire'
ptCaractere = (char *)&valeurMemoire;
ptCaractere = caractere ;
//ici tu peux utiliser valeurMemoire 
...

la ligne 'ptCaractere = caractere ;' peut générer un warning, c'est juste une piste que je te donne à creuser!!

[Thierry Chappuis]

Si tu désires récupérer la valeur (entier) du code caractère d'un caractère donné, c'est trivial et DaZumba t'a déjà montré la solution. Si c'est réellement la réprésentation binaire (chaine de '1' et de '0') qui t'intéresse (j'ai du mal à imaginer à quoi cela peut te servir), un code comme celui-ci devrait faire l'affaire:

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
#include <stdio.h>
#include <limits.h>
 
void to_binary_repr(char *buff, size_t size, unsigned char c)
{
    if (buff != NULL && size > CHAR_BIT)
    {
        size_t i;
 
        for (i = 0; i < CHAR_BIT && c > 0; i++)
        {
            buff[i] = (c >> (CHAR_BIT - 1 - i) & 0x1) + '0';
        }
        buff[i] = 0;
    }
}
 
int main(void)
{
    char s[CHAR_BIT + 1] = {0};
 
    to_binary_repr(s, sizeof s, 'A');
    puts(s);
 
    return 0;
}

Thierry

[crocodilex]

Donc je pense que tu veux récupérer cette représentation binaire de ton caractère?
Essaye un truc du genre:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
char caractere = 'A';
char * ptCaractere;
int valeurMemoire = 0;
//ton pointeur pointe sur l'adresse de l'entier qui contiendra la valeur 'binaire'
ptCaractere = (char *)&valeurMemoire;
ptCaractere = caractere ;
//ici tu peux utiliser valeurMemoire 
...

Je n'ai pas bien compris ce que tu essayes de démontrer....

la ligne 'ptCaractere = caractere ;' peut générer un warning, c'est juste une piste que je te donne à creuser!!

Et tu penses que ce warning n'est pas génant ?

[=o0 MOH =0o=]

Je n'ai pas bien compris ce que tu essayes de démontrer....

L'idée est de copier la valeur mémoire (représentation binaire) du caractère dans un entier. En tout cas c'est que je crois comprendre du but de m0ul3sh0t.

Et tu penses que ce warning n'est pas gênant ?

Un bon code est supposé être sans warning. Maintenant il faut le tester pour vérifier son fonctionnement.

[m0ul3sh0t]

en fait, si j'ai besoin de la representation en binaire, cest parce que je dois envoyer des signaux (et donc un signal pour 1 et un pour 0).
Ce que je cherchais a faire c'est recuperer la valeur de mon char en binaire pour envoyer, comme dit plus haut, un signal pour un 1 et un autre pour un 0

j'ai pensé a ce que j'ai mit en dessous
ca me permet d'envoyer mon char, sous forme binaire, et en inversant l'ordre des bits. Pour la reception je pense que ca sera plus facile pour reconstituer le message.

est ce que je me trompe?

[crocodilex]

L'idée est de copier la valeur mémoire (représentation binaire) du caractère dans un entier. En tout cas c'est que je crois comprendre du but de m0ul3sh0t.

Il est vrai que la question du P.O n'est pas très claire, mais ce que tu cherches à faire l'est encore moins.

Un bon code est supposé être sans warning. Maintenant il faut le tester pour vérifier son fonctionnement.

En effet, tu aurais dû le tester avant de poster, car ton code est faux.

[=o0 MOH =0o=]

C'est vrai que j'aurais du juste donner mon idée sans exemple de code (non testé ).
Mais encore une fois c'était pour donner une piste.

[corentin59]

en fait, si j'ai besoin de la representation en binaire, cest parce que je dois envoyer des signaux (et donc un signal pour 1 et un pour 0).
Ce que je cherchais a faire c'est recuperer la valeur de mon char en binaire pour envoyer, comme dit plus haut, un signal pour un 1 et un autre pour un 0

j'ai pensé a ce que j'ai mit en dessous
ca me permet d'envoyer mon char, sous forme binaire, et en inversant l'ordre des bits. Pour la reception je pense que ca sera plus facile pour reconstituer le message.

est ce que je me trompe?

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
#define MASK    1
 
int     main()
{
  int   i;
  char  c;
 
  i = 0;
  c = 'a';
  while (i < 7)
    {
      if ((c & MASK) == 1)
        printf("%d", 1);
      else if ((c & MASK) == 0)
        printf("%d", 0);
      c = c >> 1;
      i++;
    }
  return (0);
}

Ce code m'a l'air correct et faire ce que tu veux : afficher les bits un par un en commençant par celui de poids faible.

As-tu un pb avec ce que tu postes ?

[ramoucho75020]

Si tu désires récupérer la valeur (entier) du code caractère d'un caractère donné, c'est trivial et DaZumba t'a déjà montré la solution. Si c'est réellement la réprésentation binaire (chaine de '1' et de '0') qui t'intéresse (j'ai du mal à imaginer à quoi cela peut te servir), un code comme celui-ci devrait faire l'affaire:

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
#include <stdio.h>
#include <limits.h>
 
void to_binary_repr(char *buff, size_t size, unsigned char c)
{
    if (buff != NULL && size > CHAR_BIT)
    {
        size_t i;
 
        for (i = 0; i < CHAR_BIT && c > 0; i++)
        {
            buff[i] = (c >> (CHAR_BIT - 1 - i) & 0x1) + '0';
        }
        buff[i] = 0;
    }
}
 
int main(void)
{
    char s[CHAR_BIT + 1] = {0};
 
    to_binary_repr(s, sizeof s, 'A');
    puts(s);
 
    return 0;
}

Thierry

Bonjour je deterre un post car il m'as servi de base pour comprendre le c .
Je suis debutant et je cherche a partir d'une chaine de caractere a avoir un tableau de type int qui dans chaque case acceuil le nombre binaire de chaque caractère .

Il faut donc pour chaque caractere le lire en binaire asci et le stocker dans le nouveau tableau . pour cette lecture en binaire du caractere g utiliser l'algorithme de thierry ( merci bcp ) .

Mais seulement j'arrive pas a aller jusqu'au bout !! vous auriez des pistes ????


voici mon code :

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
#include <stdio.h>
#include <limits.h>
#include <stdlib.h>
#include <string.h>
 
#define max 30
 
void to_binary_repr(char *buff, size_t size, unsigned char c)
{
    if (buff != NULL && size > CHAR_BIT)
    {
        size_t i;
 
        for (i = 0; i < CHAR_BIT && c > 0; i++)
        {
            buff[i] = (c >> (CHAR_BIT - 1 - i) & 0x1) + '0';
        }
        buff[i] = 0;
    }
}
 
int main(void)
{
    int i ;
    int *pbinaire ;
    char message[max] ;
    char s[CHAR_BIT + 1] = {0};
    char a ;
    char *pmessage ;
    int binaire[max] ;
    char *ps ;
 
 
 
    printf("Entrer le message à coder \n");
    scanf("%s",message);
    pmessage = message ;
    pbinaire = binaire ;
 
    for (i=0 ; i<max ;i++ ) {
        a = message[i];
        to_binary_repr(s, sizeof s, a);
        /*puts(s);*/
        pbinaire[i]= ps ;
    }
 
    for (i=0 ; i<max ;i++ ) {
        printf("le caractere a convertir ",&i,"est : \n" , binaire[i]);
    }
 
 
/*
 
 
 
    printf("Entrez le caractere a convertir \n");
    scanf("%c",&a);
 
    to_binary_repr(s, sizeof s, a);
    puts(s);*/
 
    return 0;
}

[diogene]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

       pbinaire[i]= ps ;

ps est non initialisé. De plus, pbinaire[i] est un int et ps un char*.
Ceci est incohérent.

[Scoaz]

Salut m0ul3sh0t

Ce que tu veux faire est très simple en fait.
Tu a un Char, qui a par exemple pour valeur 42. Ors en binaire 42 donne 101010.
Pour récupérer Un à Un les bits contenu dans le char (8 dans un octet) il te suffit de faire des "décalages de bits".

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
i = 7
while (i >= 0)
{
printf("%d", (c >> i) & 1);
i--;
}

Le ">>" sert a faire un décalage de bits, et le "& 1" a faire un masque binaire qui permet d'isoler le bit le plus a droite de l'octet ("c" est le char). Et comme on commence par décaler de 7, les bits apparaitrons dans l'ordre.
Voilà j'espère t'avoir aidé (et que le code marche) tu peux aller sur wikipedia où ce genre de choses sont bien expliquées (il doit aussi y avoir des tutos sur le site mais je connais pas).

Bonne soirée.

[Edit] Je me rend compte que c'est ce que Thierry Chappuis a écrit (et il l'a mieux fait). Mais bon au moins c'est dit deux fois, et si on sait l'afficher on sait le stocker donc le problème devrait être réglé.

[Thierry Chappuis]

Même si je ne vois pas bien l'utilité de ce code, voici ma version:

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
#include <stdio.h>
#include <limits.h>
#include <stdlib.h>
#include <string.h>
 
#define MAX 30
 
static int 
to_binary_repr(char *buff, size_t size, unsigned char c)
{
    int err = 0;
 
    if (buff != NULL && size > CHAR_BIT)
    {
        size_t i;
 
        for (i = 0; i < CHAR_BIT && c > 0; i++)
        {
            buff[i] = (c >> (CHAR_BIT - 1 - i) & 0x1) + '0';
        }
        buff[i] = 0;
    }
    else
    {
        /* -tc- Erreur: argument invalide! */
        err = 1;
    }
 
    return err;
}
 
/* -tc- Elimine le caractere de fin de ligne saisi par fgets() et fait le
   manage dans le tampon du flux entrant en cas de saisie tronquee. */
static int 
fclean(char *buffer, FILE *fp)
{
    int err = 0;
 
    if (buffer != NULL && fp != NULL)
    {
        char *pc = strchr(buffer, '\n');
 
        if (pc != NULL)
        {
            /* -tc- la saisie est complete! On elimine le caractere de fin
               de ligne saisi. */
            *pc = 0;
        }
        else
        {
            int c;
 
            /* -tc- Avertissement: la saisie a ete tronquee */
            err = 2;
            /* -tc- on fait le menage... */
            while ((c = fgetc(fp)) != '\n' && c != EOF)
            {
            }
        }
    }
    else
    {
        /* -tc- Erreur: argument invalide */
        err = 1;
    }
 
    return err;
}
 
/* -tc- Saisit une chaine de caractere de taille mximale size - 1 a partir du
   flux entrant fp. */
static int 
fget_s(char *buffer, size_t size, FILE *fp)
{
    int err = 0;
 
    if (buffer != 0 && size > 1 && fp != NULL)
    {
        if (fgets(buffer, size, fp) != NULL)
        {
            if (fclean(buffer, fp) != 0)
            {
                /* -tc- Avertissement: saisie tronquee! */
                err = 3;
            }
        }
        else
        {
            if (feof(fp) != 0)
            {
                err = EOF;
            }
            else
            {
                /* -tc- Erreur de lecture */
                err = 2;
            }
        }
    }
    else
    {
        /* -tc- Erreur: argument invalide */
        err = 1;
    }
 
    return err;
}
 
int 
main(void)
{
    int i ;
    char message[MAX + 1] = "";
    char msg_transforme[MAX * CHAR_BIT + 1] = "";
    int ret = EXIT_SUCCESS;
 
    printf("Entrer le message à coder: ");
    fflush(stdout);
    if (fget_s(message, sizeof message, stdin) == 0)
    {
        for (i = 0; i < MAX && message[i] != 0; i++)
        {
            to_binary_repr(msg_transforme + i * CHAR_BIT, CHAR_BIT + 1, message[i]);
        }
        /* -tc- Affichage du message! */
        puts(msg_transforme);
    }
    else
    {
        ret = EXIT_FAILURE;
    }
 
    return ret;
}

Thierry