Le 15/09/06 17:45, dans <450acaa5$0$27379$,typedef struct {
int hh; //8bits 0-255
"int" n'est pas 8 bits.
Ah... même sur un microcontrôleur 8 bits ?
et c'est quoi alors le type qui va de 0 à 255 et qui occupe 8 bits ?
Le 15/09/06 17:45, dans <450acaa5$0$27379$ba4acef3@news.orange.fr>,
typedef struct {
int hh; //8bits 0-255
"int" n'est pas 8 bits.
Ah... même sur un microcontrôleur 8 bits ?
et c'est quoi alors le type qui va de 0 à 255 et qui occupe 8 bits ?
Le 15/09/06 17:45, dans <450acaa5$0$27379$,typedef struct {
int hh; //8bits 0-255
"int" n'est pas 8 bits.
Ah... même sur un microcontrôleur 8 bits ?
et c'est quoi alors le type qui va de 0 à 255 et qui occupe 8 bits ?
On pourrait également utiliser uint_fast8_t et uint_fast16_t.
Pensez à vérifier en imprimant le sizeof de votre structure qu'il
n'existe pas un ordre de déclaration des champs offrant moins de
padding. Je ne crois pas que ça puisse être le cas ici.
Si vous êtes vraiment charrette en mémoire, votez du coté des bitfields.
On pourrait également utiliser uint_fast8_t et uint_fast16_t.
Pensez à vérifier en imprimant le sizeof de votre structure qu'il
n'existe pas un ordre de déclaration des champs offrant moins de
padding. Je ne crois pas que ça puisse être le cas ici.
Si vous êtes vraiment charrette en mémoire, votez du coté des bitfields.
On pourrait également utiliser uint_fast8_t et uint_fast16_t.
Pensez à vérifier en imprimant le sizeof de votre structure qu'il
n'existe pas un ordre de déclaration des champs offrant moins de
padding. Je ne crois pas que ça puisse être le cas ici.
Si vous êtes vraiment charrette en mémoire, votez du coté des bitfields.
"int" n'est pas 8 bits.
Ah... même sur un microcontrôleur 8 bits ?
et c'est quoi alors le type qui va de 0 à 255 et qui occupe 8 bits ?
int running_chronometer = FALSE; // 0 false ; -1 true
Autant utiliser le type boll de <stdbool.h>
oui moi j'ai mis des #DEFINE pour TRUE(-1) et FALSE(0)
et puis je n'ai pas ce stdbool.h avec WinAVR (cross-compilateur pour
ATMEL AVR sous Windows)
void init_time(time_typ time) {
Très mauvaise idée de passer une structure en paramètre.
oui la bonne idée c'est de passer un pointeur sur cette structure...
"int" n'est pas 8 bits.
Ah... même sur un microcontrôleur 8 bits ?
et c'est quoi alors le type qui va de 0 à 255 et qui occupe 8 bits ?
int running_chronometer = FALSE; // 0 false ; -1 true
Autant utiliser le type boll de <stdbool.h>
oui moi j'ai mis des #DEFINE pour TRUE(-1) et FALSE(0)
et puis je n'ai pas ce stdbool.h avec WinAVR (cross-compilateur pour
ATMEL AVR sous Windows)
void init_time(time_typ time) {
Très mauvaise idée de passer une structure en paramètre.
oui la bonne idée c'est de passer un pointeur sur cette structure...
"int" n'est pas 8 bits.
Ah... même sur un microcontrôleur 8 bits ?
et c'est quoi alors le type qui va de 0 à 255 et qui occupe 8 bits ?
int running_chronometer = FALSE; // 0 false ; -1 true
Autant utiliser le type boll de <stdbool.h>
oui moi j'ai mis des #DEFINE pour TRUE(-1) et FALSE(0)
et puis je n'ai pas ce stdbool.h avec WinAVR (cross-compilateur pour
ATMEL AVR sous Windows)
void init_time(time_typ time) {
Très mauvaise idée de passer une structure en paramètre.
oui la bonne idée c'est de passer un pointeur sur cette structure...
On pourrait également utiliser uint_fast8_t et uint_fast16_t.
Pensez à vérifier en imprimant le sizeof de votre structure qu'il
n'existe pas un ordre de déclaration des champs offrant moins de
padding. Je ne crois pas que ça puisse être le cas ici.
Si vous êtes vraiment charrette en mémoire, votez du coté des bitfields.
Merci de vos conseils mais
c'est quoi le padding ?
c'est quoi les bitfields ?
On pourrait également utiliser uint_fast8_t et uint_fast16_t.
Pensez à vérifier en imprimant le sizeof de votre structure qu'il
n'existe pas un ordre de déclaration des champs offrant moins de
padding. Je ne crois pas que ça puisse être le cas ici.
Si vous êtes vraiment charrette en mémoire, votez du coté des bitfields.
Merci de vos conseils mais
c'est quoi le padding ?
c'est quoi les bitfields ?
On pourrait également utiliser uint_fast8_t et uint_fast16_t.
Pensez à vérifier en imprimant le sizeof de votre structure qu'il
n'existe pas un ordre de déclaration des champs offrant moins de
padding. Je ne crois pas que ça puisse être le cas ici.
Si vous êtes vraiment charrette en mémoire, votez du coté des bitfields.
Merci de vos conseils mais
c'est quoi le padding ?
c'est quoi les bitfields ?
#include <stdio.h>
typedef struct {
unsigned hh : 7; //7 bits 0-127
unsigned mm : 7; //7 bits 0-127
unsigned ss : 7; //7 bits 0-127
unsigned xx : 9; //9 bits 0-1024
} time_typ;
inline void init_time(time_typ* ptime) {
//*(unsigned*)ptime = 0;
*(unsigned*)ptime = 0x0000000C;// Pour le fun, initialisation à
12:00:00:000
}
int main(void)
{
time_typ t;
init_time(&t);
printf("%un", sizeof(time_typ));
printf("===%02u:%02u:%02u:%03u===n",t.hh,t.mm,t.ss,t.xx);
return 0;
}
Attention, init_time n'est pas portable, il faudrait vérifier que
sizeof(unsigned) == sizeof(time_typ).
#include <stdio.h>
typedef struct {
unsigned hh : 7; //7 bits 0-127
unsigned mm : 7; //7 bits 0-127
unsigned ss : 7; //7 bits 0-127
unsigned xx : 9; //9 bits 0-1024
} time_typ;
inline void init_time(time_typ* ptime) {
//*(unsigned*)ptime = 0;
*(unsigned*)ptime = 0x0000000C;// Pour le fun, initialisation à
12:00:00:000
}
int main(void)
{
time_typ t;
init_time(&t);
printf("%un", sizeof(time_typ));
printf("===%02u:%02u:%02u:%03u===n",t.hh,t.mm,t.ss,t.xx);
return 0;
}
Attention, init_time n'est pas portable, il faudrait vérifier que
sizeof(unsigned) == sizeof(time_typ).
#include <stdio.h>
typedef struct {
unsigned hh : 7; //7 bits 0-127
unsigned mm : 7; //7 bits 0-127
unsigned ss : 7; //7 bits 0-127
unsigned xx : 9; //9 bits 0-1024
} time_typ;
inline void init_time(time_typ* ptime) {
//*(unsigned*)ptime = 0;
*(unsigned*)ptime = 0x0000000C;// Pour le fun, initialisation à
12:00:00:000
}
int main(void)
{
time_typ t;
init_time(&t);
printf("%un", sizeof(time_typ));
printf("===%02u:%02u:%02u:%03u===n",t.hh,t.mm,t.ss,t.xx);
return 0;
}
Attention, init_time n'est pas portable, il faudrait vérifier que
sizeof(unsigned) == sizeof(time_typ).
Le 15/09/06 19:31, dans , « Pierre
Maurette » a écrit :#include <stdio.h>
typedef struct {
unsigned hh : 7; //7 bits 0-127
unsigned mm : 7; //7 bits 0-127
unsigned ss : 7; //7 bits 0-127
unsigned xx : 9; //9 bits 0-1024
} time_typ;
inline void init_time(time_typ* ptime) {
//*(unsigned*)ptime = 0;
*(unsigned*)ptime = 0x0000000C;// Pour le fun, initialisation à
12:00:00:000
Non. C'est totalement non portable. Cela dépend du CPU et des options du
compilateur pour donner le sens de remplissage de la structure.
Chez moi :
== :00:00:003==
Bien sûr que ce n'est pas portable. Il se trouve que le monsieur bosse
De plus quand on veut jouer à cela, on utilise une union, ce qui est un peu
moins sale, mais guère moins.
}
int main(void)
{
time_typ t;
init_time(&t);
printf("%un", sizeof(time_typ));
"sizeof" retourne un size_t qui ne peut pas s'afficher avec %u. Il faut
utiliser %zu ou %zd.
printf("===%02u:%02u:%02u:%03u===n",t.hh,t.mm,t.ss,t.xx);
return 0;
}
Attention, init_time n'est pas portable, il faudrait vérifier que
sizeof(unsigned) == sizeof(time_typ).
Même sans cela ce n'est pas portable.
Le 15/09/06 19:31, dans <mn.7c937d6906aebc37.31483@laposte.net>, « Pierre
Maurette » <maurettepierre@wanadoo.fr> a écrit :
#include <stdio.h>
typedef struct {
unsigned hh : 7; //7 bits 0-127
unsigned mm : 7; //7 bits 0-127
unsigned ss : 7; //7 bits 0-127
unsigned xx : 9; //9 bits 0-1024
} time_typ;
inline void init_time(time_typ* ptime) {
//*(unsigned*)ptime = 0;
*(unsigned*)ptime = 0x0000000C;// Pour le fun, initialisation à
12:00:00:000
Non. C'est totalement non portable. Cela dépend du CPU et des options du
compilateur pour donner le sens de remplissage de la structure.
Chez moi :
== :00:00:003==
Bien sûr que ce n'est pas portable. Il se trouve que le monsieur bosse
De plus quand on veut jouer à cela, on utilise une union, ce qui est un peu
moins sale, mais guère moins.
}
int main(void)
{
time_typ t;
init_time(&t);
printf("%un", sizeof(time_typ));
"sizeof" retourne un size_t qui ne peut pas s'afficher avec %u. Il faut
utiliser %zu ou %zd.
printf("===%02u:%02u:%02u:%03u===n",t.hh,t.mm,t.ss,t.xx);
return 0;
}
Attention, init_time n'est pas portable, il faudrait vérifier que
sizeof(unsigned) == sizeof(time_typ).
Même sans cela ce n'est pas portable.
Le 15/09/06 19:31, dans , « Pierre
Maurette » a écrit :#include <stdio.h>
typedef struct {
unsigned hh : 7; //7 bits 0-127
unsigned mm : 7; //7 bits 0-127
unsigned ss : 7; //7 bits 0-127
unsigned xx : 9; //9 bits 0-1024
} time_typ;
inline void init_time(time_typ* ptime) {
//*(unsigned*)ptime = 0;
*(unsigned*)ptime = 0x0000000C;// Pour le fun, initialisation à
12:00:00:000
Non. C'est totalement non portable. Cela dépend du CPU et des options du
compilateur pour donner le sens de remplissage de la structure.
Chez moi :
== :00:00:003==
Bien sûr que ce n'est pas portable. Il se trouve que le monsieur bosse
De plus quand on veut jouer à cela, on utilise une union, ce qui est un peu
moins sale, mais guère moins.
}
int main(void)
{
time_typ t;
init_time(&t);
printf("%un", sizeof(time_typ));
"sizeof" retourne un size_t qui ne peut pas s'afficher avec %u. Il faut
utiliser %zu ou %zd.
printf("===%02u:%02u:%02u:%03u===n",t.hh,t.mm,t.ss,t.xx);
return 0;
}
Attention, init_time n'est pas portable, il faudrait vérifier que
sizeof(unsigned) == sizeof(time_typ).
Même sans cela ce n'est pas portable.
Le 15/09/06 19:31, dans , « Pierre
Maurette » a écrit :#include <stdio.h>
typedef struct {
unsigned hh : 7; //7 bits 0-127
unsigned mm : 7; //7 bits 0-127
unsigned ss : 7; //7 bits 0-127
unsigned xx : 9; //9 bits 0-1024
} time_typ;
inline void init_time(time_typ* ptime) {
//*(unsigned*)ptime = 0;
*(unsigned*)ptime = 0x0000000C;// Pour le fun, initialisation à
12:00:00:000
Non. C'est totalement non portable. Cela dépend du CPU et des options du
compilateur pour donner le sens de remplissage de la structure.
"The order of allocation of bit-fields within a unit (high-order to
low-order or low-order to high-order) is implementation-defined". Ce
qui ne signifie surtout pas que ce "sens de remplissage" est déterminé
par tirage au sort.
Chez moi :
== :00:00:003== >
Bien sûr que ce n'est pas portable.
Il se trouve que le monsieur bosse
sur un microcontroleur déterminé.
Il veut un code qui marche dans sa
ROM. Il est important qu'il sache que ce n'est pas portable, et je le
lui ai signalé.
Après le padding et le bitfield (importants dans son
optique) j'ai préféré alléger ;-) le discours en zappant sur le
boutisme.
De plus quand on veut jouer à cela, on utilise une union, ce qui est un peu
moins sale, mais guère moins.
Ce n'est pas mieux. La norme est claire, une union initialisée par un
membre donne à l'utilisation de l'autre membre un comportement
"implementation-defined" - au mieux, j'ai la flemme de vérifier -.
Bref, ce n'est pas plus portable.
Néanmoins, je suis convaincu que vous
utilisez des OS sur lesquels on a utilisé l'initialisation en dur d'un
bitfield, l'accès à un lowbyte ou un word_3 en cassant la norme sur
l'union, ou en tous cas quelques __asm éminament non portables.
Il faudrait comprendre la portabilité comme une caractéristique d'un
cahier des charges et non comme une religion.
printf("%un", sizeof(time_typ));
"sizeof" retourne un size_t qui ne peut pas s'afficher avec %u. Il faut
utiliser %zu ou %zd.
Certes. Mais un size_t PEUT s'afficher avec un %u. La preuve.
Et il ne
s'agit en auc un cas de code final. Mais vous avez raison.printf("===%02u:%02u:%02u:%03u===n",t.hh,t.mm,t.ss,t.xx);
return 0;
}
Attention, init_time n'est pas portable, il faudrait vérifier que
sizeof(unsigned) == sizeof(time_typ).
Même sans cela ce n'est pas portable.
Cf plus haut. Je ne connais pas l'environnement du monsieur. Si
sizeof(unsigned) != sizeof(time_typ), ça ne fonctionnera pas. J'aurais
dû ajouter sizeof(unsigned) == 4. Et préciser que la valeur 0x0000000C
était à déterminer.
Le 15/09/06 19:31, dans <mn.7c937d6906aebc37.31483@laposte.net>, « Pierre
Maurette » <maurettepierre@wanadoo.fr> a écrit :
#include <stdio.h>
typedef struct {
unsigned hh : 7; //7 bits 0-127
unsigned mm : 7; //7 bits 0-127
unsigned ss : 7; //7 bits 0-127
unsigned xx : 9; //9 bits 0-1024
} time_typ;
inline void init_time(time_typ* ptime) {
//*(unsigned*)ptime = 0;
*(unsigned*)ptime = 0x0000000C;// Pour le fun, initialisation à
12:00:00:000
Non. C'est totalement non portable. Cela dépend du CPU et des options du
compilateur pour donner le sens de remplissage de la structure.
"The order of allocation of bit-fields within a unit (high-order to
low-order or low-order to high-order) is implementation-defined". Ce
qui ne signifie surtout pas que ce "sens de remplissage" est déterminé
par tirage au sort.
Chez moi :
== :00:00:003== >
Bien sûr que ce n'est pas portable.
Il se trouve que le monsieur bosse
sur un microcontroleur déterminé.
Il veut un code qui marche dans sa
ROM. Il est important qu'il sache que ce n'est pas portable, et je le
lui ai signalé.
Après le padding et le bitfield (importants dans son
optique) j'ai préféré alléger ;-) le discours en zappant sur le
boutisme.
De plus quand on veut jouer à cela, on utilise une union, ce qui est un peu
moins sale, mais guère moins.
Ce n'est pas mieux. La norme est claire, une union initialisée par un
membre donne à l'utilisation de l'autre membre un comportement
"implementation-defined" - au mieux, j'ai la flemme de vérifier -.
Bref, ce n'est pas plus portable.
Néanmoins, je suis convaincu que vous
utilisez des OS sur lesquels on a utilisé l'initialisation en dur d'un
bitfield, l'accès à un lowbyte ou un word_3 en cassant la norme sur
l'union, ou en tous cas quelques __asm éminament non portables.
Il faudrait comprendre la portabilité comme une caractéristique d'un
cahier des charges et non comme une religion.
printf("%un", sizeof(time_typ));
"sizeof" retourne un size_t qui ne peut pas s'afficher avec %u. Il faut
utiliser %zu ou %zd.
Certes. Mais un size_t PEUT s'afficher avec un %u. La preuve.
Et il ne
s'agit en auc un cas de code final. Mais vous avez raison.
printf("===%02u:%02u:%02u:%03u===n",t.hh,t.mm,t.ss,t.xx);
return 0;
}
Attention, init_time n'est pas portable, il faudrait vérifier que
sizeof(unsigned) == sizeof(time_typ).
Même sans cela ce n'est pas portable.
Cf plus haut. Je ne connais pas l'environnement du monsieur. Si
sizeof(unsigned) != sizeof(time_typ), ça ne fonctionnera pas. J'aurais
dû ajouter sizeof(unsigned) == 4. Et préciser que la valeur 0x0000000C
était à déterminer.
Le 15/09/06 19:31, dans , « Pierre
Maurette » a écrit :#include <stdio.h>
typedef struct {
unsigned hh : 7; //7 bits 0-127
unsigned mm : 7; //7 bits 0-127
unsigned ss : 7; //7 bits 0-127
unsigned xx : 9; //9 bits 0-1024
} time_typ;
inline void init_time(time_typ* ptime) {
//*(unsigned*)ptime = 0;
*(unsigned*)ptime = 0x0000000C;// Pour le fun, initialisation à
12:00:00:000
Non. C'est totalement non portable. Cela dépend du CPU et des options du
compilateur pour donner le sens de remplissage de la structure.
"The order of allocation of bit-fields within a unit (high-order to
low-order or low-order to high-order) is implementation-defined". Ce
qui ne signifie surtout pas que ce "sens de remplissage" est déterminé
par tirage au sort.
Chez moi :
== :00:00:003== >
Bien sûr que ce n'est pas portable.
Il se trouve que le monsieur bosse
sur un microcontroleur déterminé.
Il veut un code qui marche dans sa
ROM. Il est important qu'il sache que ce n'est pas portable, et je le
lui ai signalé.
Après le padding et le bitfield (importants dans son
optique) j'ai préféré alléger ;-) le discours en zappant sur le
boutisme.
De plus quand on veut jouer à cela, on utilise une union, ce qui est un peu
moins sale, mais guère moins.
Ce n'est pas mieux. La norme est claire, une union initialisée par un
membre donne à l'utilisation de l'autre membre un comportement
"implementation-defined" - au mieux, j'ai la flemme de vérifier -.
Bref, ce n'est pas plus portable.
Néanmoins, je suis convaincu que vous
utilisez des OS sur lesquels on a utilisé l'initialisation en dur d'un
bitfield, l'accès à un lowbyte ou un word_3 en cassant la norme sur
l'union, ou en tous cas quelques __asm éminament non portables.
Il faudrait comprendre la portabilité comme une caractéristique d'un
cahier des charges et non comme une religion.
printf("%un", sizeof(time_typ));
"sizeof" retourne un size_t qui ne peut pas s'afficher avec %u. Il faut
utiliser %zu ou %zd.
Certes. Mais un size_t PEUT s'afficher avec un %u. La preuve.
Et il ne
s'agit en auc un cas de code final. Mais vous avez raison.printf("===%02u:%02u:%02u:%03u===n",t.hh,t.mm,t.ss,t.xx);
return 0;
}
Attention, init_time n'est pas portable, il faudrait vérifier que
sizeof(unsigned) == sizeof(time_typ).
Même sans cela ce n'est pas portable.
Cf plus haut. Je ne connais pas l'environnement du monsieur. Si
sizeof(unsigned) != sizeof(time_typ), ça ne fonctionnera pas. J'aurais
dû ajouter sizeof(unsigned) == 4. Et préciser que la valeur 0x0000000C
était à déterminer.
...
Attention, init_time n'est pas portable, il faudrait vérifier que
sizeof(unsigned) == sizeof(time_typ).
...
Attention, init_time n'est pas portable, il faudrait vérifier que
sizeof(unsigned) == sizeof(time_typ).
...
Attention, init_time n'est pas portable, il faudrait vérifier que
sizeof(unsigned) == sizeof(time_typ).
Cf plus haut. Je ne connais pas l'environnement du monsieur. Si
sizeof(unsigned) != sizeof(time_typ), ça ne fonctionnera pas. J'aurais
dû ajouter sizeof(unsigned) == 4. Et préciser que la valeur 0x0000000C
était à déterminer.
Cf plus haut. Je ne connais pas l'environnement du monsieur. Si
sizeof(unsigned) != sizeof(time_typ), ça ne fonctionnera pas. J'aurais
dû ajouter sizeof(unsigned) == 4. Et préciser que la valeur 0x0000000C
était à déterminer.
Cf plus haut. Je ne connais pas l'environnement du monsieur. Si
sizeof(unsigned) != sizeof(time_typ), ça ne fonctionnera pas. J'aurais
dû ajouter sizeof(unsigned) == 4. Et préciser que la valeur 0x0000000C
était à déterminer.