¿Cómo puedo utilizar "sizeof" en una macro de preprocesador?

¿Hay alguna forma de utilizar una sizeofmacro en un preprocesador?

Por ejemplo, ha habido un montón de situaciones a lo largo de los años en las que quería hacer algo como:

#if sizeof(someThing) != PAGE_SIZE
#error Data structure doesn't match page size
#endif

Lo que estoy comprobando aquí está completamente inventado; el punto es que a menudo me gusta poner este tipo de comprobaciones en tiempo de compilación (tamaño o alineación) para evitar que alguien modifique una estructura de datos que podría desalinearse o volver a alinearse. cosas de tamaño que las romperían.

No hace falta decir que no parece que pueda usar un sizeofde la manera descrita anteriormente.

Hay varias maneras de hacer esto. Los siguientes fragmentos no producirán código si son sizeof(someThing)iguales PAGE_SIZE; de lo contrario, producirán un error en tiempo de compilación.

1. C11 way

A partir de C11 puede usar static_assert(requiere #include <assert.h>).

Uso:

static_assert(sizeof(someThing) == PAGE_SIZE, "Data structure doesn't match page size");

2. Macro personalizada

Si solo desea obtener un error en tiempo de compilación cuando sizeof(something)no es lo que esperaba, puede usar la siguiente macro:

#define BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)]))

Uso:

BUILD_BUG_ON( sizeof(someThing) != PAGE_SIZE );

Este artículo explica en detalle por qué funciona.

3. Específico para EM

En el compilador de Microsoft C ++ puede usar la macro C_ASSERT (requiere #include <windows.h>), que usa un truco similar al descrito en la sección 2.

Uso:

C_ASSERT(sizeof(someThing) == PAGE_SIZE);

¿Existe alguna forma de utilizar un " sizeof" en una macro de preprocesador?

No. Las directivas condicionales toman un conjunto restringido de expresiones condicionales; sizeofes una de las cosas no permitidas.

Las directivas de preprocesamiento se evalúan antes de que se analice la fuente (al menos conceptualmente), por lo que aún no hay tipos o variables para obtener su tamaño.

Sin embargo, existen técnicas para obtener aserciones en tiempo de compilación en C (por ejemplo, consulte esta página ).

Sé que es una respuesta tardía, pero para agregar a la versión de Mike, aquí hay una versión que usamos que no asigna memoria. No se me ocurrió la verificación de tamaño original, lo encontré en Internet hace años y, lamentablemente, no puedo hacer referencia al autor. Los otros dos son solo extensiones de la misma idea.

Debido a que son typedef, no se asigna nada. Con __LINE__ en el nombre, siempre es un nombre diferente para que se pueda copiar y pegar donde sea necesario. Esto funciona en compiladores de MS Visual Studio C y compiladores de GCC Arm. No funciona en CodeWarrior, CW se queja de la redefinición, no hace uso de la construcción del preprocesador __LINE__.

//Check overall structure size
typedef char p__LINE__[ (sizeof(PARS) == 4184) ? 1 : -1];

//check 8 byte alignment for flash write or similar
typedef char p__LINE__[ ((sizeof(PARS) % 8) == 0) ? 1 : 1];

//check offset in structure to ensure a piece didn't move
typedef char p__LINE__[ (offsetof(PARS, SUB_PARS) == 912) ? 1 : -1];

Sé que este hilo es muy antiguo pero ...

Mi solución:

extern char __CHECK__[1/!(<<EXPRESSION THAT SHOULD COME TO ZERO>>)];

Siempre que esa expresión sea igual a cero, se compilará bien. Cualquier otra cosa y explota allí mismo. Debido a que la variable es externa, no ocupará espacio y, siempre que nadie haga referencia a ella (lo que no hará), no causará un error de enlace.

No es tan flexible como la macro de aserción, pero no pude hacer que se compilara en mi versión de GCC y esto lo hará ... y creo que se compilará en casi cualquier lugar.

Las respuestas existentes solo muestran cómo lograr el efecto de "aserciones en tiempo de compilación" basadas en el tamaño de un tipo. Eso puede satisfacer las necesidades del OP en este caso particular, pero hay otros casos en los que realmente necesita un preprocesador condicional basado en el tamaño de un tipo. He aquí cómo hacerlo:

Escribe un pequeño programa en C como:

/* you could call this sizeof_int.c if you like... */
#include <stdio.h>
/* 'int' is just an example, it could be any other type */
int main(void) { printf("%zd", sizeof(int); }

Compila eso. Escriba un script en su lenguaje de script favorito, que ejecute el programa C anterior y capture su salida. Utilice esa salida para generar un archivo de encabezado C. Por ejemplo, si estuviera usando Ruby, podría verse así:

sizeof_int = `./sizeof_int`
File.open('include/sizes.h','w') { |f| f.write(<<HEADER) }
/* COMPUTER-GENERATED, DO NOT EDIT BY HAND! */
#define SIZEOF_INT #{sizeof_int}
/* others can go here... */
HEADER

Luego agregue una regla a su Makefile u otro script de compilación, lo que hará que ejecute el script anterior para compilar sizes.h.

Incluya sizes.hsiempre que necesite utilizar condicionales de preprocesador según los tamaños.

¡Hecho!

(¿Alguna vez ha escrito ./configure && makepara crear un programa? Lo que configurehacen los scripts es básicamente como el anterior ...)

¿Qué pasa con la siguiente macro?

/* 
 * Simple compile time assertion.
 * Example: CT_ASSERT(sizeof foo <= 16, foo_can_not_exceed_16_bytes);
 */
#define CT_ASSERT(exp, message_identifier) \
    struct compile_time_assertion { \
        char message_identifier : 8 + !(exp); \
    }

Por ejemplo, en el comentario MSVC dice algo como:

test.c(42) : error C2034: 'foo_can_not_exceed_16_bytes' : type of bit field too small for number of bits

Solo como referencia para esta discusión, informo que algunos compiladores obtienen sizeof () ar tiempo de preprocesador.

La respuesta de JamesMcNellis es correcta, pero algunos compiladores pasan por esta limitación (esto probablemente viola la estricta ansi c).

Como ejemplo de esto, me refiero al compilador C de IAR (probablemente el principal para microcontroladores profesionales / programación integrada).

#define SIZEOF(x) ((char*)(&(x) + 1) - (char*)&(x)) Podría funcionar

En C11 _Static_assertse agrega la palabra clave. Se puede usar como:

_Static_assert(sizeof(someThing) == PAGE_SIZE, "Data structure doesn't match page size")

En mi código portátil de C ++ ( http://www.starmessagesoftware.com/cpcclibrary/ ) quería poner una guardia segura en los tamaños de algunas de mis estructuras o clases.

En lugar de encontrar una forma para que el preprocesador arroje un error (que no puede funcionar con sizeof () como se indica aquí), encontré una solución aquí que hace que el compilador arroje un error. http://www.barrgroup.com/Embedded-Systems/How-To/C-Fixed-Width-Integers-C99

Tuve que adaptar ese código para que arrojara un error en mi compilador (xcode):

static union
{
    char   int8_t_incorrect[sizeof(  int8_t) == 1 ? 1: -1];
    char  uint8_t_incorrect[sizeof( uint8_t) == 1 ? 1: -1];
    char  int16_t_incorrect[sizeof( int16_t) == 2 ? 1: -1];
    char uint16_t_incorrect[sizeof(uint16_t) == 2 ? 1: -1];
    char  int32_t_incorrect[sizeof( int32_t) == 4 ? 1: -1];
    char uint32_t_incorrect[sizeof(uint32_t) == 4 ? 1: -1];
};

Después de probar las macro mencionadas, este fragmento parece producir el resultado deseado ( t.h):

#include <sys/cdefs.h>
#define STATIC_ASSERT(condition) typedef char __CONCAT(_static_assert_, __LINE__)[ (condition) ? 1 : -1]
STATIC_ASSERT(sizeof(int) == 4);
STATIC_ASSERT(sizeof(int) == 42);

Corriendo cc -E t.h:

# 1 "t.h"
...
# 2 "t.h" 2

typedef char _static_assert_3[ (sizeof(int) == 4) ? 1 : -1];
typedef char _static_assert_4[ (sizeof(int) == 42) ? 1 : -1];

Corriendo cc -o t.o t.h:

% cc -o t.o t.h
t.h:4:1: error: '_static_assert_4' declared as an array with a negative size
STATIC_ASSERT(sizeof(int) == 42);
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
t.h:2:84: note: expanded from macro 'STATIC_ASSERT'
  ...typedef char __CONCAT(_static_assert_, __LINE__)[ (condition) ? 1 : -1]
                                                       ^~~~~~~~~~~~~~~~~~~~
1 error generated.

42 no es la respuesta a todo después de todo ...

Para comprobar en el momento de la compilación el tamaño de las estructuras de datos frente a sus limitaciones, he utilizado este truco.

#if defined(__GNUC__)
{ char c1[sizeof(x)-MAX_SIZEOF_X-1]; } // brakets limit c1's scope
#else
{ char c1[sizeof(x)-MAX_SIZEOF_X]; }   
#endif

Si el tamaño de x es mayor o igual que su límite MAX_SIZEOF_X, entonces el gcc se quejará con un error de 'el tamaño de la matriz es demasiado grande'. VC ++ emitirá el error C2148 ('el tamaño total de la matriz no debe exceder 0x7fffffff bytes') o C4266 'no puede asignar una matriz de tamaño constante 0'.

Las dos definiciones son necesarias porque gcc permitirá definir una matriz de tamaño cero de esta manera (tamaño de x - n).

El sizeofoperador no está disponible para el preprocesador, pero puede transferirlo sizeofal compilador y verificar la condición en tiempo de ejecución:

#define elem_t double

#define compiler_size(x) sizeof(x)

elem_t n;
if (compiler_size(elem_t) == sizeof(int)) {
    printf("%d",(int)n);
} else {
    printf("%lf",(double)n);
}