Bonjour,
Désolé si c'est une FAQ.
J'ai besoin de déclarer, pour de la lecture de fichier binaires,
des types entiers dont je connais exactement le nombre de bits et le
caractère signé/non_signé.
En C99, #include <stdint.h> et déclaration du genre "int16_t
x1=-16;", et c'est réglé.
Avec certains vieux compilateurs (HP-UX pour ne pas le nommer),
c'était plutôt :
#include <stdlib.h> et déclaration du genre "int32_t x2=-32;", et
stdint.h n'existe pas.
Est-ce que les vieux routard du groupe auraient une solution, c'est
à dire une syntaxe qui marche dans les 2 cas ? (autre que créer moi-même
un stdint.h "kivabien" sur les machines où il n'existe pas)
Bonjour,
Désolé si c'est une FAQ.
J'ai besoin de déclarer, pour de la lecture de fichier binaires,
des types entiers dont je connais exactement le nombre de bits et le
caractère signé/non_signé.
En C99, #include <stdint.h> et déclaration du genre "int16_t
x1=-16;", et c'est réglé.
Avec certains vieux compilateurs (HP-UX pour ne pas le nommer),
c'était plutôt :
#include <stdlib.h> et déclaration du genre "int32_t x2=-32;", et
stdint.h n'existe pas.
Est-ce que les vieux routard du groupe auraient une solution, c'est
à dire une syntaxe qui marche dans les 2 cas ? (autre que créer moi-même
un stdint.h "kivabien" sur les machines où il n'existe pas)
Bonjour,
Désolé si c'est une FAQ.
J'ai besoin de déclarer, pour de la lecture de fichier binaires,
des types entiers dont je connais exactement le nombre de bits et le
caractère signé/non_signé.
En C99, #include <stdint.h> et déclaration du genre "int16_t
x1=-16;", et c'est réglé.
Avec certains vieux compilateurs (HP-UX pour ne pas le nommer),
c'était plutôt :
#include <stdlib.h> et déclaration du genre "int32_t x2=-32;", et
stdint.h n'existe pas.
Est-ce que les vieux routard du groupe auraient une solution, c'est
à dire une syntaxe qui marche dans les 2 cas ? (autre que créer moi-même
un stdint.h "kivabien" sur les machines où il n'existe pas)
Non, il n'y a pas. Pas de facon portable en tout cas.
Donc je suis tombé dans les #if defined, finalement assez simples
Non, il n'y a pas. Pas de facon portable en tout cas.
Donc je suis tombé dans les #if defined, finalement assez simples
Non, il n'y a pas. Pas de facon portable en tout cas.
Donc je suis tombé dans les #if defined, finalement assez simples
Marc Espie wrote:Non, il n'y a pas. Pas de facon portable en tout cas.
Donc je suis tombé dans les #if defined, finalement assez simples
dans mon cas (testé uniquement sur les quelques machines auxquelles j'ai
accès) :
#ifdef C99
#include <stdint.h>
#else
#if defined(WIN32) || defined(OS2)
typedef int int32_t;
typedef unsigned int uint32_t;
#else
/* inttypes.h fournit les dfinitions attendues sur HP-UX et gcc.
* Internet semble dire que c'est OK aussi pour AIX, sun, osf, et IRIX.
* pour les BSD, il semblerait que ce soit <sys/types.h> */
#include <inttypes.h>
#endif
#endif
Marc Espie wrote:
Non, il n'y a pas. Pas de facon portable en tout cas.
Donc je suis tombé dans les #if defined, finalement assez simples
dans mon cas (testé uniquement sur les quelques machines auxquelles j'ai
accès) :
#ifdef C99
#include <stdint.h>
#else
#if defined(WIN32) || defined(OS2)
typedef int int32_t;
typedef unsigned int uint32_t;
#else
/* inttypes.h fournit les dfinitions attendues sur HP-UX et gcc.
* Internet semble dire que c'est OK aussi pour AIX, sun, osf, et IRIX.
* pour les BSD, il semblerait que ce soit <sys/types.h> */
#include <inttypes.h>
#endif
#endif
Marc Espie wrote:Non, il n'y a pas. Pas de facon portable en tout cas.
Donc je suis tombé dans les #if defined, finalement assez simples
dans mon cas (testé uniquement sur les quelques machines auxquelles j'ai
accès) :
#ifdef C99
#include <stdint.h>
#else
#if defined(WIN32) || defined(OS2)
typedef int int32_t;
typedef unsigned int uint32_t;
#else
/* inttypes.h fournit les dfinitions attendues sur HP-UX et gcc.
* Internet semble dire que c'est OK aussi pour AIX, sun, osf, et IRIX.
* pour les BSD, il semblerait que ce soit <sys/types.h> */
#include <inttypes.h>
#endif
#endif
Marc Espie wrote:
Non, il n'y a pas. Pas de facon portable en tout cas.
Donc je suis tombé dans les #if defined, finalement assez simples dans
mon cas (testé uniquement sur les quelques machines auxquelles j'ai accès) :
#ifdef C99
#include <stdint.h>
#else
#if defined(WIN32) || defined(OS2)
typedef int int32_t;
typedef unsigned int uint32_t;
#else
/* inttypes.h fournit les dfinitions attendues sur HP-UX et gcc.
* Internet semble dire que c'est OK aussi pour AIX, sun, osf, et IRIX.
* pour les BSD, il semblerait que ce soit <sys/types.h> */
#include <inttypes.h>
#endif
#endif
Marc Espie wrote:
Non, il n'y a pas. Pas de facon portable en tout cas.
Donc je suis tombé dans les #if defined, finalement assez simples dans
mon cas (testé uniquement sur les quelques machines auxquelles j'ai accès) :
#ifdef C99
#include <stdint.h>
#else
#if defined(WIN32) || defined(OS2)
typedef int int32_t;
typedef unsigned int uint32_t;
#else
/* inttypes.h fournit les dfinitions attendues sur HP-UX et gcc.
* Internet semble dire que c'est OK aussi pour AIX, sun, osf, et IRIX.
* pour les BSD, il semblerait que ce soit <sys/types.h> */
#include <inttypes.h>
#endif
#endif
Marc Espie wrote:
Non, il n'y a pas. Pas de facon portable en tout cas.
Donc je suis tombé dans les #if defined, finalement assez simples dans
mon cas (testé uniquement sur les quelques machines auxquelles j'ai accès) :
#ifdef C99
#include <stdint.h>
#else
#if defined(WIN32) || defined(OS2)
typedef int int32_t;
typedef unsigned int uint32_t;
#else
/* inttypes.h fournit les dfinitions attendues sur HP-UX et gcc.
* Internet semble dire que c'est OK aussi pour AIX, sun, osf, et IRIX.
* pour les BSD, il semblerait que ce soit <sys/types.h> */
#include <inttypes.h>
#endif
#endif
Dans l'article <f3onte$pre$,
PIGUET Bruno écrit:Marc Espie wrote:Non, il n'y a pas. Pas de facon portable en tout cas.
Donc je suis tombé dans les #if defined, finalement assez simples
dans mon cas (testé uniquement sur les quelques machines auxquelles j'ai
accès) :
#ifdef C99
#if __STDC__ == 1 && __STDC_VERSION__ >= 199901#include <stdint.h>
#else
#if defined(WIN32) || defined(OS2)
typedef int int32_t;
typedef unsigned int uint32_t;
#else
/* inttypes.h fournit les dfinitions attendues sur HP-UX et gcc.
* Internet semble dire que c'est OK aussi pour AIX, sun, osf, et IRIX.
* pour les BSD, il semblerait que ce soit <sys/types.h> */
#include <inttypes.h>
#endif
#endif
Mieux vaut peut-être définir un my_int32_t (avec les typedef qu'il
faut suivant le contexte), car certains en-têtes liés à la plateforme
peuvent définir int32_t. Si je me souviens bien, c'était le cas sous
Solaris avec juste un #include <unistd.h>. Imagine qu'on ait le même
genre de problème sous Windows ou OS/2...
Dans l'article <f3onte$pre$1@sxcom1.cnrm.meteo.fr>,
PIGUET Bruno <bruno.piguet@meteo.fr> écrit:
Marc Espie wrote:
Non, il n'y a pas. Pas de facon portable en tout cas.
Donc je suis tombé dans les #if defined, finalement assez simples
dans mon cas (testé uniquement sur les quelques machines auxquelles j'ai
accès) :
#ifdef C99
#if __STDC__ == 1 && __STDC_VERSION__ >= 199901
#include <stdint.h>
#else
#if defined(WIN32) || defined(OS2)
typedef int int32_t;
typedef unsigned int uint32_t;
#else
/* inttypes.h fournit les dfinitions attendues sur HP-UX et gcc.
* Internet semble dire que c'est OK aussi pour AIX, sun, osf, et IRIX.
* pour les BSD, il semblerait que ce soit <sys/types.h> */
#include <inttypes.h>
#endif
#endif
Mieux vaut peut-être définir un my_int32_t (avec les typedef qu'il
faut suivant le contexte), car certains en-têtes liés à la plateforme
peuvent définir int32_t. Si je me souviens bien, c'était le cas sous
Solaris avec juste un #include <unistd.h>. Imagine qu'on ait le même
genre de problème sous Windows ou OS/2...
Dans l'article <f3onte$pre$,
PIGUET Bruno écrit:Marc Espie wrote:Non, il n'y a pas. Pas de facon portable en tout cas.
Donc je suis tombé dans les #if defined, finalement assez simples
dans mon cas (testé uniquement sur les quelques machines auxquelles j'ai
accès) :
#ifdef C99
#if __STDC__ == 1 && __STDC_VERSION__ >= 199901#include <stdint.h>
#else
#if defined(WIN32) || defined(OS2)
typedef int int32_t;
typedef unsigned int uint32_t;
#else
/* inttypes.h fournit les dfinitions attendues sur HP-UX et gcc.
* Internet semble dire que c'est OK aussi pour AIX, sun, osf, et IRIX.
* pour les BSD, il semblerait que ce soit <sys/types.h> */
#include <inttypes.h>
#endif
#endif
Mieux vaut peut-être définir un my_int32_t (avec les typedef qu'il
faut suivant le contexte), car certains en-têtes liés à la plateforme
peuvent définir int32_t. Si je me souviens bien, c'était le cas sous
Solaris avec juste un #include <unistd.h>. Imagine qu'on ait le même
genre de problème sous Windows ou OS/2...
Marc Espie wrote:
Non, il n'y a pas. Pas de facon portable en tout cas.
Donc je suis tombé dans les #if defined, finalement assez simples dans
mon cas (testé uniquement sur les quelques machines auxquelles j'ai accès) :
#ifdef C99
#include <stdint.h>
#else
#if defined(WIN32) || defined(OS2)
typedef int int32_t;
typedef unsigned int uint32_t;
#else
/* inttypes.h fournit les dfinitions attendues sur HP-UX et gcc.
* Internet semble dire que c'est OK aussi pour AIX, sun, osf, et IRIX.
* pour les BSD, il semblerait que ce soit <sys/types.h> */
#include <inttypes.h>
#endif
#endif
En C99, les types intN_t et uintN_t garantissent un nombre exact de
bits sans padding et pour les signés une représentation en complément à
2. En vertu de quoi, ces types sont optionnels, c'est à dire qu'ils ne
seront pas implémentés si la plateforme ne le possède pas en natif. La
norme précise que les types seront (il me semble que c'est un "shall"
cher à la norme) implémentés - typedef-ed - dans le cas contraire.
Le choix est fait pour chaque paire signé - non signé, les deux types
doivent être implémentés, ou aucun.
Le préprocesseur n'a pas accès à sizeof, mais vous pouvez inclure
limits.h. Vous pouvez peut-être vous en sortir au plus près de la norme
C99 avec un truc comme:
#include <limits.h>
#if CHAR_MAX == 2147483647 && CHAR_MIN == -2147483648 && UCHAR_MAX ==
4294967295
/* faire les typedef */
#elif SHRT_MAX == 2147483647 && SHRT_MIN == -2147483648 && USHRT_MAX ==
4294967295
/* faire les typedef */
#elif INT_MAX == 2147483647 && INT_MIN == -2147483648 && UINT_MAX ==
4294967295
/* faire les typedef */
#elif LONG_MAX == 2147483647 && LONG_MIN == -2147483648 && ULONG_MAX ==
4294967295
/* faire les typedef */
#else
#error Aucun type ne correspond à int32_t / uint32_t
#endif
Marc Espie wrote:
Non, il n'y a pas. Pas de facon portable en tout cas.
Donc je suis tombé dans les #if defined, finalement assez simples dans
mon cas (testé uniquement sur les quelques machines auxquelles j'ai accès) :
#ifdef C99
#include <stdint.h>
#else
#if defined(WIN32) || defined(OS2)
typedef int int32_t;
typedef unsigned int uint32_t;
#else
/* inttypes.h fournit les dfinitions attendues sur HP-UX et gcc.
* Internet semble dire que c'est OK aussi pour AIX, sun, osf, et IRIX.
* pour les BSD, il semblerait que ce soit <sys/types.h> */
#include <inttypes.h>
#endif
#endif
En C99, les types intN_t et uintN_t garantissent un nombre exact de
bits sans padding et pour les signés une représentation en complément à
2. En vertu de quoi, ces types sont optionnels, c'est à dire qu'ils ne
seront pas implémentés si la plateforme ne le possède pas en natif. La
norme précise que les types seront (il me semble que c'est un "shall"
cher à la norme) implémentés - typedef-ed - dans le cas contraire.
Le choix est fait pour chaque paire signé - non signé, les deux types
doivent être implémentés, ou aucun.
Le préprocesseur n'a pas accès à sizeof, mais vous pouvez inclure
limits.h. Vous pouvez peut-être vous en sortir au plus près de la norme
C99 avec un truc comme:
#include <limits.h>
#if CHAR_MAX == 2147483647 && CHAR_MIN == -2147483648 && UCHAR_MAX ==
4294967295
/* faire les typedef */
#elif SHRT_MAX == 2147483647 && SHRT_MIN == -2147483648 && USHRT_MAX ==
4294967295
/* faire les typedef */
#elif INT_MAX == 2147483647 && INT_MIN == -2147483648 && UINT_MAX ==
4294967295
/* faire les typedef */
#elif LONG_MAX == 2147483647 && LONG_MIN == -2147483648 && ULONG_MAX ==
4294967295
/* faire les typedef */
#else
#error Aucun type ne correspond à int32_t / uint32_t
#endif
Marc Espie wrote:
Non, il n'y a pas. Pas de facon portable en tout cas.
Donc je suis tombé dans les #if defined, finalement assez simples dans
mon cas (testé uniquement sur les quelques machines auxquelles j'ai accès) :
#ifdef C99
#include <stdint.h>
#else
#if defined(WIN32) || defined(OS2)
typedef int int32_t;
typedef unsigned int uint32_t;
#else
/* inttypes.h fournit les dfinitions attendues sur HP-UX et gcc.
* Internet semble dire que c'est OK aussi pour AIX, sun, osf, et IRIX.
* pour les BSD, il semblerait que ce soit <sys/types.h> */
#include <inttypes.h>
#endif
#endif
En C99, les types intN_t et uintN_t garantissent un nombre exact de
bits sans padding et pour les signés une représentation en complément à
2. En vertu de quoi, ces types sont optionnels, c'est à dire qu'ils ne
seront pas implémentés si la plateforme ne le possède pas en natif. La
norme précise que les types seront (il me semble que c'est un "shall"
cher à la norme) implémentés - typedef-ed - dans le cas contraire.
Le choix est fait pour chaque paire signé - non signé, les deux types
doivent être implémentés, ou aucun.
Le préprocesseur n'a pas accès à sizeof, mais vous pouvez inclure
limits.h. Vous pouvez peut-être vous en sortir au plus près de la norme
C99 avec un truc comme:
#include <limits.h>
#if CHAR_MAX == 2147483647 && CHAR_MIN == -2147483648 && UCHAR_MAX ==
4294967295
/* faire les typedef */
#elif SHRT_MAX == 2147483647 && SHRT_MIN == -2147483648 && USHRT_MAX ==
4294967295
/* faire les typedef */
#elif INT_MAX == 2147483647 && INT_MIN == -2147483648 && UINT_MAX ==
4294967295
/* faire les typedef */
#elif LONG_MAX == 2147483647 && LONG_MIN == -2147483648 && ULONG_MAX ==
4294967295
/* faire les typedef */
#else
#error Aucun type ne correspond à int32_t / uint32_t
#endif
Si on veut un type d'exactement la bonne taille, c'est effectivement un
probleme. stdint.h prevoit INT32_MIN pour verifier l'existence du type.
Si on veut des types d'au moins une certaine taille, il vaut mieux
utiliser int_least32_t et consorts. Ceux-la sont obligatoire vis-a-vis
de la norme.
Le préprocesseur n'a pas accès à sizeof, mais vous pouvez inclure
limits.h. Vous pouvez peut-être vous en sortir au plus près de la norme
C99 avec un truc comme:
#include <limits.h>
#if CHAR_MAX == 2147483647 && CHAR_MIN == -2147483648 && UCHAR_MAX ==
4294967295
/* faire les typedef */
#elif SHRT_MAX == 2147483647 && SHRT_MIN == -2147483648 && USHRT_MAX ==
4294967295
/* faire les typedef */
#elif INT_MAX == 2147483647 && INT_MIN == -2147483648 && UINT_MAX ==
4294967295
/* faire les typedef */
#elif LONG_MAX == 2147483647 && LONG_MIN == -2147483648 && ULONG_MAX ==
4294967295
/* faire les typedef */
#else
#error Aucun type ne correspond à int32_t / uint32_t
#endif
C'est pour du pre-C99, je suppose ?
Si on veut un type d'exactement la bonne taille, c'est effectivement un
probleme. stdint.h prevoit INT32_MIN pour verifier l'existence du type.
Si on veut des types d'au moins une certaine taille, il vaut mieux
utiliser int_least32_t et consorts. Ceux-la sont obligatoire vis-a-vis
de la norme.
Le préprocesseur n'a pas accès à sizeof, mais vous pouvez inclure
limits.h. Vous pouvez peut-être vous en sortir au plus près de la norme
C99 avec un truc comme:
#include <limits.h>
#if CHAR_MAX == 2147483647 && CHAR_MIN == -2147483648 && UCHAR_MAX ==
4294967295
/* faire les typedef */
#elif SHRT_MAX == 2147483647 && SHRT_MIN == -2147483648 && USHRT_MAX ==
4294967295
/* faire les typedef */
#elif INT_MAX == 2147483647 && INT_MIN == -2147483648 && UINT_MAX ==
4294967295
/* faire les typedef */
#elif LONG_MAX == 2147483647 && LONG_MIN == -2147483648 && ULONG_MAX ==
4294967295
/* faire les typedef */
#else
#error Aucun type ne correspond à int32_t / uint32_t
#endif
C'est pour du pre-C99, je suppose ?
Si on veut un type d'exactement la bonne taille, c'est effectivement un
probleme. stdint.h prevoit INT32_MIN pour verifier l'existence du type.
Si on veut des types d'au moins une certaine taille, il vaut mieux
utiliser int_least32_t et consorts. Ceux-la sont obligatoire vis-a-vis
de la norme.
Le préprocesseur n'a pas accès à sizeof, mais vous pouvez inclure
limits.h. Vous pouvez peut-être vous en sortir au plus près de la norme
C99 avec un truc comme:
#include <limits.h>
#if CHAR_MAX == 2147483647 && CHAR_MIN == -2147483648 && UCHAR_MAX ==
4294967295
/* faire les typedef */
#elif SHRT_MAX == 2147483647 && SHRT_MIN == -2147483648 && USHRT_MAX ==
4294967295
/* faire les typedef */
#elif INT_MAX == 2147483647 && INT_MIN == -2147483648 && UINT_MAX ==
4294967295
/* faire les typedef */
#elif LONG_MAX == 2147483647 && LONG_MIN == -2147483648 && ULONG_MAX ==
4294967295
/* faire les typedef */
#else
#error Aucun type ne correspond à int32_t / uint32_t
#endif
C'est pour du pre-C99, je suppose ?
#ifdef C99
#if __STDC__ == 1 && __STDC_VERSION__ >= 199901
#include <stdint.h>
#else
#ifdef C99
#if __STDC__ == 1 && __STDC_VERSION__ >= 199901
#include <stdint.h>
#else
#ifdef C99
#if __STDC__ == 1 && __STDC_VERSION__ >= 199901
#include <stdint.h>
#else
[...]Si on veut un type d'exactement la bonne taille, c'est effectivement un
probleme. stdint.h prevoit INT32_MIN pour verifier l'existence du type.
Le problème dépasse celui de la taille. A partir du moment où l'on
asserte (franglais ?) que l'on dispose de int32_t, on peut faire des
hypothèses sûres que l'on ne peut pas faire autrement. Manque quand
même le boutisme, qui rest indéterminé à priori.Si on veut des types d'au moins une certaine taille, il vaut mieux
utiliser int_least32_t et consorts. Ceux-la sont obligatoire vis-a-vis
de la norme.
J'ai eu récemment un doute. Sur un truc appelé éventuellement à être
optimisé en final, j'avais besoin d'un type contenant une somme de
quelques dizaines de uint8_t. J'ai donc choisi (via un typedef, pour
pouvoir tester) un uint_fast16_t, démarche logique aujourd'hui. J'étais
avec un gcc assez vieux sous Windows, cible 32bit. J'ai regardé le
sizeof, je m'attendais à 4, j'ai lu 2. J'ai changé pour un unsigned,
démarche logique hier. Pour des boucles de calculs sur entiers, il
aurait fallu l'intervention de l'arbitre vidéo pour départager. Mais à
partir du moment où j'avais une conversion en double à un niveau
intermédiaire de la boucle, l'avantage à l'int était flagrant. De
l'ordre de 400 -> 300 en unités quelconques de temps. Il se trouve que
c'est une boucle assez stratégique dans l'appli, ça m'inquiète. Sans
plus puisque ça doit se compiler avec un gcc récent et le -march qui va
bien, ou alors Icc 8.1.
C'était pour Bruno et son HP-UX.
J'admets d'ailleurs que la certitude de trouver un type natif de 32
bits sans padding avec complément à deux n'est peut-être pas garantie
par rapport à la norme avec mes tests. Mais sur les archi que je
connais personnellement, et celles dont je connais l'existence par
fr.comp.lang.c, ça fonctionne.
[...]
Si on veut un type d'exactement la bonne taille, c'est effectivement un
probleme. stdint.h prevoit INT32_MIN pour verifier l'existence du type.
Le problème dépasse celui de la taille. A partir du moment où l'on
asserte (franglais ?) que l'on dispose de int32_t, on peut faire des
hypothèses sûres que l'on ne peut pas faire autrement. Manque quand
même le boutisme, qui rest indéterminé à priori.
Si on veut des types d'au moins une certaine taille, il vaut mieux
utiliser int_least32_t et consorts. Ceux-la sont obligatoire vis-a-vis
de la norme.
J'ai eu récemment un doute. Sur un truc appelé éventuellement à être
optimisé en final, j'avais besoin d'un type contenant une somme de
quelques dizaines de uint8_t. J'ai donc choisi (via un typedef, pour
pouvoir tester) un uint_fast16_t, démarche logique aujourd'hui. J'étais
avec un gcc assez vieux sous Windows, cible 32bit. J'ai regardé le
sizeof, je m'attendais à 4, j'ai lu 2. J'ai changé pour un unsigned,
démarche logique hier. Pour des boucles de calculs sur entiers, il
aurait fallu l'intervention de l'arbitre vidéo pour départager. Mais à
partir du moment où j'avais une conversion en double à un niveau
intermédiaire de la boucle, l'avantage à l'int était flagrant. De
l'ordre de 400 -> 300 en unités quelconques de temps. Il se trouve que
c'est une boucle assez stratégique dans l'appli, ça m'inquiète. Sans
plus puisque ça doit se compiler avec un gcc récent et le -march qui va
bien, ou alors Icc 8.1.
C'était pour Bruno et son HP-UX.
J'admets d'ailleurs que la certitude de trouver un type natif de 32
bits sans padding avec complément à deux n'est peut-être pas garantie
par rapport à la norme avec mes tests. Mais sur les archi que je
connais personnellement, et celles dont je connais l'existence par
fr.comp.lang.c, ça fonctionne.
[...]Si on veut un type d'exactement la bonne taille, c'est effectivement un
probleme. stdint.h prevoit INT32_MIN pour verifier l'existence du type.
Le problème dépasse celui de la taille. A partir du moment où l'on
asserte (franglais ?) que l'on dispose de int32_t, on peut faire des
hypothèses sûres que l'on ne peut pas faire autrement. Manque quand
même le boutisme, qui rest indéterminé à priori.Si on veut des types d'au moins une certaine taille, il vaut mieux
utiliser int_least32_t et consorts. Ceux-la sont obligatoire vis-a-vis
de la norme.
J'ai eu récemment un doute. Sur un truc appelé éventuellement à être
optimisé en final, j'avais besoin d'un type contenant une somme de
quelques dizaines de uint8_t. J'ai donc choisi (via un typedef, pour
pouvoir tester) un uint_fast16_t, démarche logique aujourd'hui. J'étais
avec un gcc assez vieux sous Windows, cible 32bit. J'ai regardé le
sizeof, je m'attendais à 4, j'ai lu 2. J'ai changé pour un unsigned,
démarche logique hier. Pour des boucles de calculs sur entiers, il
aurait fallu l'intervention de l'arbitre vidéo pour départager. Mais à
partir du moment où j'avais une conversion en double à un niveau
intermédiaire de la boucle, l'avantage à l'int était flagrant. De
l'ordre de 400 -> 300 en unités quelconques de temps. Il se trouve que
c'est une boucle assez stratégique dans l'appli, ça m'inquiète. Sans
plus puisque ça doit se compiler avec un gcc récent et le -march qui va
bien, ou alors Icc 8.1.
C'était pour Bruno et son HP-UX.
J'admets d'ailleurs que la certitude de trouver un type natif de 32
bits sans padding avec complément à deux n'est peut-être pas garantie
par rapport à la norme avec mes tests. Mais sur les archi que je
connais personnellement, et celles dont je connais l'existence par
fr.comp.lang.c, ça fonctionne.
Ben non, elle n'est effectivement pas garantie. Il existe effectivement
des archis exotiques, plutot du cote des DSP, qui ne gerent en natif que
des valeurs 64 bits.
Ben non, elle n'est effectivement pas garantie. Il existe effectivement
des archis exotiques, plutot du cote des DSP, qui ne gerent en natif que
des valeurs 64 bits.
Ben non, elle n'est effectivement pas garantie. Il existe effectivement
des archis exotiques, plutot du cote des DSP, qui ne gerent en natif que
des valeurs 64 bits.