Como posso usar “sizeof” em uma macro de pré-processador?

Existe alguma maneira de usar um sizeofem uma macro de pré-processador?

Por exemplo, houve uma tonelada de situações ao longo dos anos em que eu queria fazer algo como:

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

A coisa exata que estou verificando aqui está completamente inventada - o que quero dizer é que geralmente gosto de incluir esses tipos de (tamanho ou alinhamento) verificações de tempo de compilação para evitar que alguém modifique uma estrutura de dados que poderia desalinhar ou re- dimensionar coisas que os quebrariam.

Desnecessário dizer - não pareço ser capaz de usar um sizeofda maneira descrita acima.

Existem várias maneiras de fazer isso. Os snippets a seguir não produzirão nenhum código sesizeof(someThing) iguais PAGE_SIZE; caso contrário, eles produzirão um erro em tempo de compilação.

1. caminho C11

Começando com C11, você pode usar static_assert(requer #include <assert.h>).

Uso:

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

2. Macro personalizada

Se você apenas deseja obter um erro de tempo de compilação quando sizeof(something)não é o que você esperava, você pode usar a seguinte macro:

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

Uso:

BUILD_BUG_ON( sizeof(someThing) != PAGE_SIZE );

Este artigo explica em detalhes por que funciona.

3. Específico de MS

No compilador Microsoft C ++, você pode usar a macro C_ASSERT (requer #include <windows.h>), que usa um truque semelhante ao descrito na seção 2.

Uso:

C_ASSERT(sizeof(someThing) == PAGE_SIZE);

Existe alguma maneira de usar um " sizeof" em uma macro de pré-processador?

Não. As diretivas condicionais usam um conjunto restrito de expressões condicionais; sizeofé uma das coisas não permitidas.

As diretivas de pré-processamento são avaliadas antes que a fonte seja analisada (pelo menos conceitualmente), portanto, não há nenhum tipo ou variável para obter seu tamanho.

No entanto, existem técnicas para obter asserções de tempo de compilação em C (por exemplo, consulte esta página ).

Eu sei que é uma resposta tardia, mas para acrescentar à versão de Mike, aqui está uma versão que usamos que não aloca nenhuma memória. Eu não vim com a verificação do tamanho original, encontrei na internet anos atrás e infelizmente não posso citar o autor. Os outros dois são apenas extensões da mesma ideia.

Por serem typedef's, nada é alocado. Com __LINE__ no nome, é sempre um nome diferente para que possa ser copiado e colado quando necessário. Isso funciona em compiladores MS Visual Studio C e compiladores GCC Arm. Não funciona no CodeWarrior, CW reclama da redefinição, não fazendo uso da construção do pré-processador __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];

Eu sei que este tópico é muito antigo, mas ...

Minha solução:

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

Contanto que essa expressão seja igual a zero, ela compila bem. Qualquer outra coisa e explodirá bem ali. Como a variável é externa, ela não ocupará espaço e, desde que ninguém faça referência a ela (o que eles não farão), não causará um erro de link.

Não tão flexível quanto a macro assert, mas não consegui compilar na minha versão do GCC e isso irá ... e acho que irá compilar em qualquer lugar.

As respostas existentes mostram apenas como obter o efeito de "afirmações em tempo de compilação" com base no tamanho de um tipo. Isso pode atender às necessidades do OP neste caso específico, mas há outros casos em que você realmente precisa de uma condicional de pré-processador com base no tamanho de um tipo. Veja como fazer:

Escreva para você mesmo um pequeno programa 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); }

Compile isso. Escreva um script em sua linguagem de script favorita, que executa o programa C acima e captura sua saída. Use essa saída para gerar um arquivo de cabeçalho C. Por exemplo, se você estiver usando Ruby, pode ser parecido com:

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

Em seguida, adicione uma regra ao seu Makefile ou outro script de construção, que fará com que ele execute o script acima para construir sizes.h.

Inclua sizes.hsempre que for necessário usar condicionais de pré-processador com base em tamanhos.

Feito!

(Você já digitou ./configure && makepara construir um programa? O que os configurescripts fazem é basicamente igual ao descrito acima ...)

E a próxima 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 exemplo, em comentário, o MSVC diz algo como:

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

Apenas como referência para esta discussão, relato que alguns compiladores obtêm sizeof () ou tempo de pré-processador.

A resposta do JamesMcNellis está correta, mas alguns compiladores passam por essa limitação (isso provavelmente viola o ansi c estrito).

Nesse caso, refiro-me ao compilador IAR C (provavelmente o líder para microcontrolador profissional / programação embarcada).

#define SIZEOF(x) ((char*)(&(x) + 1) - (char*)&(x)) pode funcionar

Em C11, a _Static_assertpalavra-chave é adicionada. Pode ser usado como:

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

No meu código c ++ portátil ( http://www.starmessagesoftware.com/cpcclibrary/ ), queria colocar uma guarda segura nos tamanhos de algumas das minhas estruturas ou classes.

Em vez de encontrar uma maneira de o pré-processador lançar um erro (que não pode funcionar com sizeof () conforme declarado aqui), encontrei uma solução aqui que faz com que o compilador emita um erro. http://www.barrgroup.com/Embedded-Systems/How-To/C-Fixed-Width-Integers-C99

Tive que adaptar esse código para que ele gerasse um erro no meu 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];
};

Depois de experimentar a macro mencionada, este fragmento parece produzir o resultado desejado ( 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);

Em execução 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];

Em execução 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.

Afinal, 42 não é a resposta para tudo ...

Para verificar em tempo de compilação o tamanho das estruturas de dados em relação às suas restrições, usei este truque.

#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

Se o tamanho de x for maior ou igual ao seu limite MAX_SIZEOF_X, o gcc reclamará com um erro de 'tamanho do array é muito grande'. O VC ++ emitirá o erro C2148 ('o tamanho total da matriz não deve exceder 0x7fffffff bytes') ou C4266 'não pode alocar uma matriz de tamanho constante 0'.

As duas definições são necessárias porque o gcc permitirá que um array de tamanho zero seja definido dessa forma (sizeof x - n).

O sizeofoperador não está disponível para o pré-processador, mas você pode transferir sizeofpara o compilador e verificar a condição no tempo de execução:

#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);
}