Which preprocessor directive or other method should I use to recognize the 32-bit environment of the 64-bit version?
I would like to compile the following C program for 32 and 64 bit systems.
#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);
}
What I was doing with mine Makefile
is to go through -m32
and -64
to create bitfiles:
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
This works great, but when I compile, I run into a warning:
$ make
gcc -m32 -ansi -pedantic -Wall -O3 -c main.c -o main32_array.o
gcc -m32 -ansi -pedantic -Wall -O3 main32_array.o -o arrayTest32
gcc -m64 -ansi -pedantic -Wall -O3 -c main.c -o main64_array.o
main.c: In function ‘main’:
main.c:14: warning: format ‘%u’ expects type ‘unsigned int’, but argument 3 has type ‘long unsigned int’
gcc -m64 -ansi -pedantic -Wall -O3 main64_array.o -o arrayTest64
What I would like to do is fix this warning by not having two main.c files for two "bit" targets.
Is there or #ifndef
some other conditional preprocessor I can add to line 14 of main.c
to handle this difference?
Or is there another and better way to handle this?
EDIT : I used the following solution:
#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
a source to share
You don't want to have an #ifdef for every line of code that might be different from this - it won't scale.
The problem is that sizeof () returns a 64 bit count at a 64 bit level. One possible fix:
fprintf (stdout, "memory allocated on the heap:% u bytes \ n", (unsigned int) (sizeof (int) * size));
If you know the number will always be 32 bits.
a source to share
The accepted answer is ok if you need to be portable for non-C99 compilers (like Visual Studio), but since you only seem to be using gcc, I highly recommend #define __STDC_FORMAT_MACROS and use PRI * macros as I described here . Then you don't have to sprinkle your code with unnecessary #ifdefs every time you need to print a 64-bit integer.
a source to share