Est-il un GCC directive de préprocesseur pour vérifier si le code est compilé sur un ordinateur 64 bits?

Je suis en train de faire quelque chose comme ce qui suit;

#ifdef 64-bit
    #define DECIMAL_FORMAT %ld
#else
    #define DECIMAL_FORMAT %d
#endif
.
intptr_t d;  
.
printf(“Some message with DECIMAL_FORMAT in the middle of it\n”, d);

La variable " d "etre de type "intptr_t" besoins "%d' spécificateur de format de 32 bits machines et spécificateur de format '%ld' sur 64 bits machines. Je suis à la recherche d'une solution pour pouvoir compiler le code sur 32 bits machines et 64 bits des machines sans apporter de modifications à la GCC en ligne de commande ou dans le code source.

OriginalL'auteur Vilmorin | 2009-03-25

  1. 24

    Je pense __LP64__ peut-être ce que vous cherchez. Voir http://gcc.gnu.org/onlinedocs/gcc-4.1.2/cpp/Common-Predefined-Macros.html

    Peut-être une meilleure façon d'aller, cependant, est d'utiliser le %p spécificateur de printf() au lieu de %ld ou %d. Ensuite, vous n'avez même pas à vous inquiéter à ce que le pointeur de la souris de taille.

    OriginalL'auteur Fred Larson

  2. 8

    Vous souhaitez utiliser le PRI* des macros définies dans inttypes.h. Vous permettre en définissant __STDC\_FORMAT\_MACROS. Vous pouvez ensuite utiliser

     intptr_t d = ... ;
 printf("This is an intptr_t: %" PRIxPTR "\n", d);

    La PRIxPTR macro s'étendre à llx si __WORDSIZE == 64, et lx ou x autrement.

    +1 vraiment cool. Cependant, les résultats sur mon x86-64 système Debian sont légèrement différentes. "echo __WORDSIZE | g++ -xc++ -comportent des limites.h -P -E -" retourne 64. "echo PRIxPTR | g++ -xc++ -D__STDC_FORMAT_MACROS -inclure inttypes.h -E - | tail -1" retourne "l" "x".
    Eh bien, la PRI*-les macros sont c99, donc si vous pouvez démontrer qu'ils sont mauvais comportement sur votre machine, vous devriez probablement signaler un bug pour les gens de debian.
    Ma conjecture est la suivante: "l" "x" est "lx", ce qui est bien si les pointeurs et long sont à la fois 64 bits ou 32 bits; "llx est vraiment nécessaire pour imprimer un pointeur seulement si sizeof(void*) == sizeof(long long) mais sizeof(long long) > sizeof(long)

    OriginalL'auteur JesperE

  3. 1

    Une solution recommandée est de rendre votre application se comporte de façon plus prévisible. Si vous le rendre dépendant de la taille d'un pointeur de mémoire, vous pouvez avoir quelques surprises indésirables. Printf comprend uniquement un petit nombre de types, si vous devez imprimer une valeur d'un type que vous ne pouvez pas toujours vous assurer qu'il est vraiment connue, il est beaucoup mieux pour le convertir en quelque chose de connu.

    printf("Some message with %ld in the middle of it\n", (long) d);

    C'est un bon conseil, et valable pour n'importe quel type. Par exemple, pour imprimer un Unix PID (qui est de type pid_t):

    pid_t pid = fork();
printf("Fork returned %d.\n", (int) pid);

    Vous n'avez pas à savoir quel est le type et la taille de pid, aussi longtemps que le type de cible est assez grand.

    Je suis d'accord avec votre philosophie générale, mais notez que vous ne devriez pas compter sur les pointeurs en s'inscrivant dans une longue. Sur Windows 64 bits, ils ne le font pas (msdn.microsoft.com/en-us/library/s3f49ktz(SV.71).aspx). Pour les pointeurs, "%p" est la bonne façon (comme Fred Larsen souligné).

    OriginalL'auteur Juliano