Problème pour caster une variable

Version imprimable

06/08/2018, 15h33
tengalice49

Problème pour caster une variable

Bonjour, j'ai probleme pour caster une variable.
J'ai le prototype de fonction suivant:

Code:

void UART_puts(uart_id_e uart_id, uint8_t * str, uint8_t len)

Lorsque j'initialise comme cela:

Code:

char str[11];

Et que je cast la variable comme cela:

Code:

UART_puts(UART3_ID, (uint8_t*)str, sizeof(str)); //Send the message to UART3 (Sigfox module)

Je n'ai pas de probleme, cela fonctionne.

Cependant, quand j'initialise comme cela:

Code:

uint8_t c;

Je ne sais pas comment utiliser ma variable dans la fonction UART_puts.
Quand j'ecris cela:

Code:

UART_puts(UART2_ID, (uint8_t)c, sizeof(c)); //send frame to uart 2 (USB)

J'obtiens cette erreur:

Citation:

../Src/main.c:306:25: warning: passing argument 2 of 'UART_puts' makes pointer from integer without a cast [-Wint-conversion]
UART_puts(UART2_ID, (uint8_t)c, sizeof(c)); //send frame to uart 2 (USB)

Quand j'ecris cela:

Code:

UART_puts(UART2_ID, (uint8_t*)c, sizeof(c)); //send frame to uart 2 (USB)

J'obtiens cette erreur:

Citation:

../Src/main.c:306:25: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
UART_puts(UART2_ID, (uint8_t*)c, sizeof(c)); //send frame to uart 2 (USB)
^

Et quand j'ecris cela:

Code:

UART_puts(UART2_ID, c, sizeof(c)); //send frame to uart 2 (USB)

J'obtiens cette erreur:

Citation:

../Src/main.c:306:25: warning: passing argument 2 of 'UART_puts' makes pointer from integer without a cast [-Wint-conversion]
UART_puts(UART2_ID, c, sizeof(c)); //send frame to uart 2 (USB)
^

Comment faire pour cette variable c soit "compatible" avec le prototype de fonction? Merci.
06/08/2018, 16h29
Bousk

Il te faut un pointeur, donc operateur & UART_puts(UART2_ID, &c, 1);
06/08/2018, 23h06
tengalice49

Ok merci!

Quelle est la difference entre

Citation:

*c

et

Citation:

&c

?

Quelle différence ? Il va sérieusement falloir réouvrir un cours de C à la rubrique "pointeurs" ! :aie:

Un code simple :
Code:

1 2 3 4 5 6 int main() { int i = 42; // une variable int* p = &i; // un pointeur initialisé avec l'adresse de cette variable *p = 17; // modification de la variable pointée return i; // renvoie 17 }
&c a un sens quelque soit le type de la variable c : c'est son adresse ; *c n'a un sens que si le type de la variable c est "pointeur sur TOTO" : c'est la variable pointée, de type "TOTO".

07/08/2018, 09h13
tengalice49

Merci!
07/08/2018, 13h54
Bktero
J'oubliais juste de dire quelque chose de plus profond : caster, c'est mal.

Quand tu castes, tu dis au compilateur : considère une variable comme étant d'un autre type, ne fait pas de vérification dessus. Des fois, ton cast fait trop n'importe quoi alors le compilateur râle quand même, mais en général, tu risques de masquer des problèmes. Si ton code est correct, tu as normalement jamais besoin de caster. Si tu as besoin de le faire, il faut faire très attention et avec de bonnes raisons. Juste "faire taire un warning du compilateur" n'est pas une bonne raison.

Un exemple tout simple pour mieux me faire comprendre :
Code:

1 2 3 4 5 6 7 8 9 10 #include <stdio.h> void print(float* p) { printf("%f", *p); } int main() { int i = 31415; print(&i); }
Ce code génère un warning :
```
main.c: In function 'main':
main.c:9:11: warning: passing argument 1 of 'print' from incompatible pointer type [-Wincompatible-pointer-types]
     print(&i);
           ^
main.c:3:6: note: expected 'float *' but argument is of type 'int *'
 void print(float* p) {
      ^~~~~
```
Avec un cast, plus de warning ! Youpi !
Code:

1 2 3 4 5 6 7 8 9 10 #include <stdio.h> void print(float* p) { printf("%f", *p); } int main() { int i = 31415; print((float*) &i); }
Sauf qu'à l’exécution ça ne fonctionne pas...
Code:

1 2 0.000000 Process finished with exit code 0
PS : en C++, ce n'est pas un warning, c'est carrément une erreur !
```
main.cpp:9:13: error: cannot convert 'int*' to 'float*' for argument '1' to 'void print(float*)'
     print(&i);
```
Avec un cast, plus d'erreur... Youpi...
08/08/2018, 18h15
Sve@r
Bonjour

Citation:

Envoyé par Bktero

Sauf qu'à l’exécution ça ne fonctionne pas...

Quand j'ai vu ça, je me suis dit "ok, je m'en vais te me le faire fonctionner ce cast !!!". :mrgreen:
Ben non. J'ai tout essayé (à partir de "i" casté en float) mais non, rien à faire.

Ci-joint un de mes essais (ne compile pas)
Code:

1 2 3 4 5 6 7 8 9 10 #include <stdio.h> void print(float* p) { printf("%f\n", *p); } int main() { int i = 31415; print((float*)(&((float)i))); }
En fait, le souci, c'est que "i" casté en float n'est pas mis en mémoire et n'a donc pas d'adresse exploitable.

Bravo :applo: Bel exemple de cast foireux et irréparable :chin:

Citation:

Envoyé par Bktero

Youpi...

Ouais pareil ouais :arf:

Le l'adresse semble correcte, mais l'affichage est toujours de 0..
Code:

1 2 3 4 5 6 7 8 9 void print(float* p) { printf("%p:%f\n", p, *p); } int main() { int i = 31415; print((float*)((((void*)&i)))); printf("%p", &i); }
Code:

1 2 0x7ffc0cd40a2c:0.000000 0x7ffc0cd40a2c
Mais dans le debugger, la valeur de *p dans printf apparait comme 4.40217913e-41, et effectivement si on l'affiche avec la notation scientifique (%e), elle apparait.

Peut-etre l'endianess et la representation en memoire du float qui entrent en jeu.
Ca me rapelle https://bousk.developpez.com/traduct...alisation/#LIV

08/08/2018, 20h03
Sve@r

Citation:

Envoyé par Bousk

Le l'adresse semble correcte, mais l'affichage est toujours de 0.
...
Peut-etre l'endianess et la representation en memoire du float qui entrent en jeu.

Exactement. L'adresse de i ça restera l'adresse de i quoi qu'il arrive. C'est la façon de décoder son contenu qui fait toute la différence.
"i" est un int (4 octets) qui vaut 31415. Ce nombre "31415" est alors codé à la façon d'un int (une bête conversion de "31415" en binaire qui s'étale sur les 32 bits de cette variable).
Ensuite, dans la fonction print il est écrit "on reçoit l'adresse d"un float". Quand ensuite la fonction utilise cette adresse (qui est alors la même, tout le monde en convient) et tente de convertir ce qui s'y trouve, ben elle utilise pour ça le codage des floats (mantisse, exposant, etc). Et là, le résultat n'est plus du tout la même chose alors que le contenu des 32 bits est le même. Simplement il n'est pas lu de la même façon.

Dans "le crime de l'Orient Express" (Agatha Christie), à un moment Hercule Poirot tombe sur un mouchoir avec une lettre "H" brodée. Il cherche alors partout à qui appartient ce mouchoir (et bien évidemment on a un personnage dénommé "Hubbard" et un autre dénommé "Hildegarde" sinon mettre ce mouchoir dans l'intrigue n'aurait servi à rien).
Et à la fin, il révèle qu'en caractère russe, le "H" se lit "N" et que le mouchoir appartient à Natalia Dragomirov. On a ici le même principe. Dans un alphabet un "H" se lit "H" et dans un autre il se lit "N". Et dans un codage X une suite de bits se lira "31415" et dans un autre, la même suite se lira "4.40217913e-41".

La seule façon d'avoir "31415" à l'écran au sortir de l'affichage d'un float, c'est de réorganiser les bits qui composent ce nombre au format "float" avant de les envoyer à la fonction. Et la seule façon de faire ça est de recopier "i" dans une autre variable float => float f=(float)i (j'ai écrit le cast pour montrer qu'il existe mais si on ne le met pas il est alors implicite)

PS: Dans "Indiana Jones et la dernière croisade" (ouais, j'ai des références :mrgreen:) il est dit qu'en latin, un "J" s'écrit "I"...
09/08/2018, 08h40
Bktero
Citation:

Envoyé par Sve@r

Bravo :applo: Bel exemple de cast foireux et irréparable :chin:

Merci :)

Citation:

Envoyé par Bousk

Le l'adresse semble correcte
[...]
Peut-etre l'endianess et la representation en memoire du float qui entrent en jeu.

Citation:

Envoyé par Sve@r

Exactement. L'adresse de i ça restera l'adresse de i quoi qu'il arrive. C'est la façon de décoder son contenu qui fait toute la différence.

En effet, tout est question de représentation ici. Le problème vient du fait qu'ici on caste un pointeur. On peut faire tous les casts qu'on veut, l'adresse reste la même et quand on regarde ce qu'il y a à cette adresse, on y trouve un entier 32 bits (sans doute représenté en complément à 2) et on interprète ces bits comme un flottant 32 bits en IEE754. Très peu probable que ça donne la même valeur dans les 2 représentations...

Si la fonction print() prenait un flottant un paramètre (au lieu d'un pointeur sur flottant), l'affichage pourrait être correct. En effet, il existe des conversions légales entre types. Voici un tel code :
Code:

1 2 3 4 5 6 7 8 9 10 #include <stdio.h> void print(float p) { printf("%f", p); } int main() { int i = 31415; print(i); }
Compilé avec -Wall -Wextra, il n'y a pas de warning.

En ajoutant -Wconversion, le compilateur nous avertit d'une possible perte :
```
main.c:9:8: warning: conversion to 'float' from 'int' may alter its value [-Wconversion]
  print(i);
        ^
```
Citation:

-Wconversion
Warn for implicit conversions that may alter a value. This includes conversions between real and integer, like abs (x) when x is double; conversions between signed and unsigned, like unsigned ui = -1; and conversions to smaller types, like sqrtf (M_PI). Do not warn for explicit casts like abs ((int) x) and ui = (unsigned) -1, or if the value is not changed by the conversion like in abs (2.0). Warnings about conversions between signed and unsigned integers can be disabled by using -Wno-sign-conversion.

For C++, also warn for confusing overload resolution for user-defined conversions; and conversions that never use a type conversion operator: conversions to void, the same type, a base class or a reference to them. Warnings about conversions between signed and unsigned integers are disabled by default in C++ unless -Wsign-conversion is explicitly enabled.

Bien sûr, un cast empêche le warning d'apparaitre. Dans les 2 cas, la sortie console est bien 31415.000000. En revanche, si i = 987654321, alors la sortie devient 987654336.000000... Et de manière marrante, si i =987654336 alors la sortie est toujours 987654336.000000 est correcte :lol:

PS : amusez-vous à rajouter -Wconversion à vos projets, vous allez sans doute vous marrer :mrgreen: