Welche Präprozessordirektive oder andere Methode sollte ich verwenden, um eine 32- oder 64-Bit-Umgebung zu erkennen?

Question

Ich möchte das folgende Programm C für 32- und 64-Bit-Systeme kompilieren.

#include <stdio.h>                                         
#include <stdlib.h>                                         
#include <stddef.h>                                         

int main(int argc, char** argv) { 
    size_t size = atoi(argv[1]);                                      
    int *array;                                          

    array = malloc(size * sizeof(int));                                    
    if (array == NULL) {                                        
    fprintf(stderr, "could not allocate memory\n");                                 
    exit(1);                                           
    }                                             
    fprintf(stdout, "memory allocated on heap: %u bytes\n", sizeof(int)*size);                           

    fprintf(stdout, "press Return to quit\n");                                   
    getchar();                                           

    fprintf(stdout, "freeing memory\n");                                    
    free(array);                                          

    exit(0);                                           
}   

Was ich mit meiner Makefile tun, ist in -m32 und -64 passieren bitspezifischer Binaries zu machen:

CFLAGS=-ansi -pedantic -Wall -O3 
32BIT_ARCH=-m32 
64BIT_ARCH=-m64 
32_CFLAGS=${32BIT_ARCH} ${CFLAGS} 
64_CFLAGS=${64BIT_ARCH} ${CFLAGS} 
CC=gcc 
ARRAY_32BIT_BINARY_NAME=arrayTest32 
ARRAY_64BIT_BINARY_NAME=arrayTest64 

all: ${ARRAY_32BIT_BINARY_NAME} ${ARRAY_64BIT_BINARY_NAME} 
arrayTest32: main32_array.o 
      ${CC} ${32_CFLAGS} main32_array.o -o ${ARRAY_32BIT_BINARY_NAME} 
arrayTest64: main64_array.o 
      ${CC} ${64_CFLAGS} main64_array.o -o ${ARRAY_64BIT_BINARY_NAME} 
main32_array.o: main.c 
      ${CC} ${32_CFLAGS} -c main.c -o main32_array.o 
main64_array.o: main.c 
      ${CC} ${64_CFLAGS} -c main.c -o main64_array.o 
clean: 
      -rm *.o *~ ${ARRAY_32BIT_BINARY_NAME} ${ARRAY_64BIT_BINARY_NAME} 
install: 
      cp ${ARRAY_32BIT_BINARY_NAME} ${ARRAY_64BIT_BINARY_NAME} ../bin 

Dies funktioniert gut, aber ich laufe in eine Warnung beim Kompilieren:

Was ich tun möchte, ist diese Warnung zu beheben, ohne zwei main.c-Dateien für zwei "Bit" -Ziele zu haben.

Gibt es eine #ifndef oder andere Präprozessor bedingte Ich kann Zeile 14 von main.c hinzufügen, um diesen Unterschied zu behandeln?

Oder gibt es einen anderen und besseren Weg, damit umzugehen?

EDIT: habe ich die folgende Lösung:

#if defined(__LP64__)                                        
    fprintf(stdout, "memory allocated on heap: %lu bytes\n", sizeof(int)*size);                          
#else                                            
    fprintf(stdout, "memory allocated on heap: %u bytes\n", sizeof(int)*size);                           
#endif  

Answer 1

here Siehe für eine ähnliche Frage.

LP64 _LP64 Diese Makros definiert werden, mit dem Wert 1, wenn (und nur wenn) die Kompilierung für ein Ziel ist, wo lange int und der Zeiger verwenden beide 64-Bit und int 32 verwendet -Bit.

Answer 2

How can I detect if I'm compiling for a 64bits architecture in C++

Answer 3

Sie möchten keine #ifdef für jede Codezeile haben, die sich so unterscheiden könnte - sie wird nicht skaliert.

Das Problem ist, dass sizeof() eine 64-Bit-Menge auf 64-Bit zurückgibt. Eine mögliche Lösung:

fprintf (stdout, "Speicher auf Heap reserviert:% u Bytes \ n", (unsigned int) (sizeof (int) * Größe));

Vorausgesetzt, Sie wissen, dass die Anzahl immer 32 Bit beträgt.

Answer 4

C99 bietet den 'z' Modifikator für den Druck size_t Werte; Verwenden Sie das in der Formatzeichenfolge.

Answer 5

Die akzeptierte Antwort ist in Ordnung, wenn Sie zu Nicht-C99-Compilern (wie Visual Studio) portierbar sein müssen, aber da Sie scheinen, nur gcc zu verwenden, würde ich stark empfehlen, #define __STDC_FORMAT_MACROS zu definieren und das PRI zu verwenden * Makros, wie ich beschrieben habe here. Dann müssen Sie Ihren Code nicht jedes Mal mit unnötigen #ifdefs versehen, wenn Sie eine 64-Bit-Ganzzahl drucken müssen.