Discussion :

[alfy]

C'est tout simplement impossible.

Si tu déclares deux entiers de type int, il te parait évident qu'ils seront à deux emplacements différents dans la mémoire et que donc les adresses seront différentes ?

Il n'est donc pas possible qu'un objet float et qu'un objet char* aient la même adresse. En revanche, tu peux créer un pointeur sur float et lui donner comme valeur l'adresse de la chaine :

Code :

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

1
2
3
4
5
6
7
8
9
10
int main(void)
{
    char *chaine = "\x45\x2d\xb6\x32";
    float *p_energie = chaine;
 
    printf("'%s' a l'adresse %p\n", chaine, chaine);
    printf("'%f' a l'adresse %p\n", *p_energie, p_energie);
 
    return 0;
}

Rien ne te garantit par contre que l'interprétation des 4 octets de chaine via le pointeur p_energie donne un résultat probant.

Oui, je l'avais déjà codé ainsi (entre autre) mais chez moi cela ne marche pas !!!


Par contre je ne comprends pas pourquoi 2 variables de type différents
ne peuvent pas avoir la même adresse, le compilateur (gcc) le permet pourtant (Je pensais que C permettait tout - a ses risques et périls bien sûr -

Alfy

[Bktero]

Si tu exécutes mon code chez toi, il t'affiche quoi ?

Par contre je ne comprends pas pourquoi 2 variables de type différents
ne peuvent pas avoir la même adresse, le compilateur (gcc) le permet pourtant (Je pensais que C permettait tout - a ses risques et périls bien sûr -

Je peux me tromper mais pour la simple et bonne raison que le fait que les objets soient de types différents ne changent rien au fait que chacun à besoin de mémoire pour être stocké et que s'ils sont à la même adresse, ils vont s'écraser l'un l'autre.

Où as-tu vu cette possibilité dans gcc ? Comment l'as-tu codé ?

Tu peux faire quelque chose dans ce sens avec une union :

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
int main(void)
{
    union
    {
        unsigned char chaine[sizeof(float)];
        float energie;
    } combine;
 
    combine.chaine[0] = 0x45;
    combine.chaine[1] = 0x2d;
    combine.chaine[2] = 0xb6;
    combine.chaine[3] = 0x32;
 
    printf("'%s' a l'adresse %p\n", combine.chaine, combine.chaine);
    printf("'%f' a l'adresse %p\n", combine.energie, &combine.energie);
 
 
    return 0;
}

Je ne suis pas sûr et certain de la portabilité de ce code. Tu peux regarder ici si cela t'intéresse.

[pfeuh]

Je veux a présent que l'adresse du float soit l'adresse de chaine

union est fait pour ça.

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
#include <stdio.h>
#include <stdlib.h>
 
typedef union MYDATA
{
    unsigned char bytes[4];
    float f32;
} MYDATA;
 
int main(void)
{
    MYDATA value;
 
    value.f32 = 123.456;
    printf("%02x %02x %02x %02x\n", value.bytes[0], value.bytes[1], value.bytes[2], value.bytes[3]);
    return 0;
}

[alfy]

A chaque coup cela me donne 0.000000

Même résultat avec l'union.....

Je peux me tromper mais pour la simple et bonne raison que le fait que les objets soient de types différents ne changent rien au fait que chacun à besoin de mémoire pour être stocké et que s'ils sont à la même adresse, ils vont s'écraser l'un l'autre.

Où as-tu vu cette possibilité dans gcc ? Comment l'as-tu codé ?

J'ai essayé plein de manière différentes, je ne peux pas te les dire comme cela, mais cela passait à la compilation. Mais peu importe, pourvu que j'aie la solution.

[Bktero]

Pfeuh confirme mes dires, on peut lui faire confiance !

A chaque coup cela me donne 0.000000

je t'avais prévenu que cela ne donnait pas forcément un résultat valable.

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
    union
    {
        unsigned char chaine[sizeof(float)];
        unsigned int hexa;
        float energie;
    } combine;
 
    combine.chaine[0] = 0x45;
    combine.chaine[1] = 0x2d;
    combine.chaine[2] = 0xb6;
    combine.chaine[3] = 0x32;
 
    printf("'%s' a l'adresse %p\n", combine.chaine, combine.chaine);
    printf("'%X' a l'adresse %p\n", combine.hexa, &combine.hexa);
    printf("'%f' a l'adresse %p\n", combine.energie, &combine.energie);

Il faut revoir l'endianess de la chaine, comme l'avait dit....... pfeuh !!!!!

[alfy]

Je vous suis les yeux fermés, mon C a 20 ans au moins et je n'y reviens que très ponctuellement, c'est vous dire si je fais confiance en vos conseils

Mais

Chez moi ce code


char *value = "\x45\x2d\xb6\x32";

typedef union ENERGY
{
unsigned char bytes[4];
float f32;

} ENERGY;

int main(void)
{
ENERGY energie;
energie.bytes[0] = *(value + 0);
printf("%x\n", energie.bytes[0]);
energie.bytes[1] = *(value + 1);
printf("%x\n", energie.bytes[1]);
energie.bytes[2] = *(value + 2);
printf("%x\n", energie.bytes[2]);
energie.bytes[3] = *(value + 3);
printf("%x\n", energie.bytes[3]);

printf("%f", energie.f32);

return 0;
}

Me donne toujours 0.000000

Pouvez-vous me dire si chez vous c'est pareil ?

@Bktero l'endianless est bon.. de toute manière cela doit afficher autre chose que ce maudit 0.000000

Merci

[Bktero]

Non, l'endianess n'est pas bon. Le code précédent le montre, avec le champ supplémentaire hexa que j'ai rajouté à l'union.

Il faut inverser l'ordre des bytes :

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
char *value = "\x45\x2d\xb6\x32";
 
typedef union ENERGY
{
    unsigned char bytes[4];
    float f32;
} ENERGY;
 
int main(void)
{
    ENERGY energie;
    energie.bytes[3] = *(value + 0);
    printf("%x\n", energie.bytes[0]);
    energie.bytes[2] = *(value + 1);
    printf("%x\n", energie.bytes[1]);
    energie.bytes[1] = *(value + 2);
    printf("%x\n", energie.bytes[2]);
    energie.bytes[0] = *(value + 3);
    printf("%x\n", energie.bytes[3]);
 
    printf("%f", energie.f32);
 
    return 0;
}

[alfy]

Mille excuses Bktero, j'aurai du t'écouter plus tôt.
Maintenant ça marche.

En tout cas, merci à vous 2

Alfy