Qual é o seu truque de programação C favorito? [fechadas]

Por exemplo, recentemente deparei com isso no kernel do linux:

/ * Força um erro de compilação se a condição for verdadeira * /
#define BUILD_BUG_ON (condição) ((nulo) sizeof (char [1 - 2 * !! (condição)]))

Portanto, no seu código, se você tem alguma estrutura que deve ser, digamos um múltiplo de 8 bytes de tamanho, talvez por causa de algumas restrições de hardware, você pode:

BUILD_BUG_ON ((tamanho da estrutura)% 8)! = 0);

e não será compilado, a menos que o tamanho da estrutura mystruct seja múltiplo de 8 e, se for múltiplo de 8, nenhum código de tempo de execução será gerado.

Outro truque que conheço é do livro "Graphics Gems", que permite que um único arquivo de cabeçalho declare e inicialize variáveis ​​em um módulo enquanto em outros módulos usando esse módulo, apenas as declara como externas.

#ifdef DEFINE_MYHEADER_GLOBALS
#define GLOBAL
#define INIT (x, y) (x) = (y)
#outro
#define GLOBAL extern
#define INIT (x, y)
#fim se

GLOBAL int INIT (x, 0);
GLOBAL int de alguma forma (int a, int b);

Com isso, o código que define x e somefunc faz:

#define DEFINE_MYHEADER_GLOBALS
#include "the_above_header_file.h"

enquanto o código que está apenas usando x e somefunc () faz:

#include "the_above_header_file.h"

Portanto, você obtém um arquivo de cabeçalho que declara as instâncias de protótipos globais e de função onde elas são necessárias e as declarações externas correspondentes.

Então, quais são seus truques favoritos de programação C nesse sentido?

O C99 oferece coisas muito legais usando matrizes anônimas:

Removendo Variáveis ​​Inúteis

{
    int yes=1;
    setsockopt(yourSocket, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int));
}

torna-se

setsockopt(yourSocket, SOL_SOCKET, SO_REUSEADDR, (int[]){1}, sizeof(int));

Passando uma quantidade variável de argumentos

void func(type* values) {
    while(*values) {
        x = *values++;
        /* do whatever with x */
    }
}

func((type[]){val1,val2,val3,val4,0});

Listas vinculadas estáticas

int main() {
    struct llist { int a; struct llist* next;};
    #define cons(x,y) (struct llist[]){{x,y}}
    struct llist *list=cons(1, cons(2, cons(3, cons(4, NULL))));
    struct llist *p = list;
    while(p != 0) {
        printf("%d\n", p->a);
        p = p->next;
    }
}

Qualquer um que eu tenha certeza de muitas outras técnicas legais em que não pensei.

Ao ler o código-fonte do Quake 2, vim com algo assim:

double normals[][] = {
  #include "normals.txt"
};

(mais ou menos, não tenho o código à mão para verificá-lo agora).

Desde então, um novo mundo de uso criativo do pré-processador se abriu diante dos meus olhos. Não incluo mais apenas cabeçalhos, mas pedaços inteiros de código de vez em quando (melhora muito a reutilização) :-p

Obrigado John Carmack! xD

Eu gosto de usar = {0};para inicializar estruturas sem precisar chamar memset.

struct something X = {0};

Isso inicializará todos os membros da estrutura (ou matriz) para zero (mas não quaisquer bytes de preenchimento - use memset se você precisar zerá-los também).

Mas você deve estar ciente de que existem alguns problemas com isso para estruturas grandes e dinamicamente alocadas .

Se estamos falando de truques c, meu favorito deve ser o dispositivo de Duff para desenrolar o loop! Só estou esperando a oportunidade certa para eu realmente usá-lo com raiva ...

usando __FILE__e __LINE__para depuração

#define WHERE fprintf(stderr,"[LOG]%s:%d\n",__FILE__,__LINE__);

Em C99

typedef struct{
    int value;
    int otherValue;
} s;

s test = {.value = 15, .otherValue = 16};

/* or */
int a[100] = {1,2,[50]=3,4,5,[23]=6,7};

Uma vez um colega meu e eu redefinimos o retorno para encontrar um bug de corrupção de pilha complicado.

Algo como:

#define return DoSomeStackCheckStuff, return

Eu gosto do "struct hack" por ter um objeto de tamanho dinâmico. Este site também explica muito bem (embora eles se refiram à versão C99, na qual você pode escrever "str []" como o último membro de uma estrutura). você poderia criar uma string "objeto" assim:

struct X {
    int len;
    char str[1];
};

int n = strlen("hello world");
struct X *string = malloc(sizeof(struct X) + n);
strcpy(string->str, "hello world");
string->len = n;

aqui, alocamos uma estrutura do tipo X no heap que é do tamanho de um int (para len), mais o tamanho do "hello world" e mais 1 (desde str 1 está incluído no (X).

Geralmente é útil quando você deseja ter um "cabeçalho" antes de alguns dados de comprimento variável no mesmo bloco.

Código orientado a objeto com C, emulando classes.

Basta criar uma estrutura e um conjunto de funções que levam um ponteiro para essa estrutura como primeiro parâmetro.

Ao invés de

printf("counter=%d\n",counter);

Usar

#define print_dec(var)  printf("%s=%d\n",#var,var);
print_dec(counter);

Usando um truque estúpido de macro para facilitar a manutenção das definições de registro.

#define COLUMNS(S,E) [(E) - (S) + 1]

typedef struct
{
    char studentNumber COLUMNS( 1,  9);
    char firstName     COLUMNS(10, 30);
    char lastName      COLUMNS(31, 51);

} StudentRecord;

Para criar uma variável que é somente leitura em todos os módulos, exceto aquele em que está declarada:

// Header1.h:

#ifndef SOURCE1_C
   extern const int MyVar;
#endif

// Source1.c:

#define SOURCE1_C
#include Header1.h // MyVar isn't seen in the header

int MyVar; // Declared in this file, and is writeable

// Source2.c

#include Header1.h // MyVar is seen as a constant, declared elsewhere

Os desvios de bits são definidos apenas até um valor de desvio de 31 (em um número inteiro de 32 bits).

O que você faz se deseja ter um turno computado que também precisa trabalhar com valores de turno mais altos? Aqui está como o videocodec Theora faz isso:

unsigned int shiftmystuff (unsigned int a, unsigned int v)
{
  return (a>>(v>>1))>>((v+1)>>1);
}

Ou muito mais legível:

unsigned int shiftmystuff (unsigned int a, unsigned int v)
{
  unsigned int halfshift = v>>1;
  unsigned int otherhalf = (v+1)>>1;

  return (a >> halfshift) >> otherhalf; 
}

Executar a tarefa da maneira mostrada acima é muito mais rápido do que usar um ramo como este:

unsigned int shiftmystuff (unsigned int a, unsigned int v)
{
  if (v<=31)
    return a>>v;
  else
    return 0;
}

Declarando matriz de ponteiro para funções para implementar máquinas de estados finitos.

int (* fsm[])(void) = { ... }

A vantagem mais agradável é que é simples forçar cada estímulo / estado a verificar todos os caminhos de código.

Em um sistema incorporado, frequentemente mapeio um ISR para apontar para uma tabela e a reveciono conforme necessário (fora do ISR).

Outro bom "truque" do pré-processador é usar o caractere "#" para imprimir expressões de depuração. Por exemplo:

#define MY_ASSERT(cond) \
  do { \
    if( !(cond) ) { \
      printf("MY_ASSERT(%s) failed\n", #cond); \
      exit(-1); \
    } \
  } while( 0 )

editar: o código abaixo funciona apenas em C ++. Agradecimentos a smcameron e Evan Teran.

Sim, a afirmação do tempo de compilação é sempre ótima. Também pode ser escrito como:

#define COMPILE_ASSERT(cond)\
     typedef char __compile_time_assert[ (cond) ? 0 : -1]

Eu realmente não chamaria isso de um truque favorito, já que nunca o usei, mas a menção de Duff's Device me lembrou este artigo sobre a implementação de Coroutines em C. Ele sempre me dá uma risada, mas tenho certeza que poderia seja útil por algum tempo.

#if TESTMODE == 1    
    debug=1;
    while(0);     // Get attention
#endif

O tempo (0); não tem efeito no programa, mas o compilador emitirá um aviso sobre "isso não faz nada", o que é suficiente para que eu olhe para a linha incorreta e veja o verdadeiro motivo pelo qual eu queria chamar atenção.

Sou fã de xor hacks:

Troque 2 ponteiros sem o terceiro indicador temporário:

int * a;
int * b;
a ^= b;
b ^= a;
a ^= b;

Ou eu realmente gosto da lista vinculada xor com apenas um ponteiro. (http://en.wikipedia.org/wiki/XOR_linked_list)

Cada nó na lista vinculada é o Xor do nó anterior e o próximo nó. Para avançar, o endereço dos nós é encontrado da seguinte maneira:

LLNode * first = head;
LLNode * second = first.linked_nodes;
LLNode * third = second.linked_nodes ^ first;
LLNode * fourth = third.linked_nodes ^ second;

etc.

ou para recuar:

LLNode * last = tail;
LLNode * second_to_last = last.linked_nodes;
LLNode * third_to_last = second_to_last.linked_nodes ^ last;
LLNode * fourth_to_last = third_to_last.linked_nodes ^ second_to_last;

etc.

Embora não seja muito útil (você não pode começar a atravessar a partir de um nó arbitrário), acho muito legal.

Este vem do livro 'Bastante corda para se dar um tiro no pé':

No cabeçalho declare

#ifndef RELEASE
#  define D(x) do { x; } while (0)
#else
#  define D(x)
#endif

No seu código, coloque as instruções de teste, por exemplo:

D(printf("Test statement\n"));

O do / while ajuda no caso de o conteúdo da macro se expandir para várias instruções.

A instrução será impressa apenas se o sinalizador '-D RELEASE' do compilador não for usado.

Você pode, por exemplo, passe a bandeira para o seu makefile etc.

Não sei como isso funciona no Windows, mas no * nix funciona bem

O Rusty realmente produziu todo um conjunto de condicionais de compilação no ccan , confira o módulo de construção de declaração :

#include <stddef.h>
#include <ccan/build_assert/build_assert.h>

struct foo {
        char string[5];
        int x;
};

char *foo_string(struct foo *foo)
{
        // This trick requires that the string be first in the structure
        BUILD_ASSERT(offsetof(struct foo, string) == 0);
        return (char *)foo;
}

Existem muitas outras macros úteis no cabeçalho real, fáceis de colocar no lugar.

Eu tento, com todas as minhas forças, resistir à atração do lado sombrio (e ao abuso do pré-processador) aderindo principalmente às funções embutidas, mas eu gosto de macros inteligentes e úteis, como as que você descreveu.

Dois bons livros-fonte para esse tipo de coisa são The Practice of Programming and Writing Solid Code . Um deles (não me lembro qual) diz: Prefira enum a #define onde você puder, porque enum é verificado pelo compilador.

Não é específico para C, mas sempre gostei do operador XOR. Uma coisa legal que ele pode fazer é "trocar sem um valor temporário":

int a = 1;
int b = 2;

printf("a = %d, b = %d\n", a, b);

a ^= b;
b ^= a;
a ^= b;

printf("a = %d, b = %d\n", a, b);

Resultado:

a = 1, b = 2

a = 2, b = 1

Consulte "Recursos ocultos de C" pergunta .

Eu gosto do conceito de container_of usado, por exemplo, em listas. Basicamente, você não precisa especificar nextelast campos para cada estrutura que vai estar na lista. Em vez disso, você anexa o cabeçalho da estrutura da lista aos itens vinculados reais.

Veja include/linux/list.hexemplos da vida real.

Eu acho que o uso de ponteiros de dados do usuário é bem legal. Uma moda perdendo terreno hoje em dia. Não é tanto um recurso C, mas é muito fácil de usar em C.

Eu uso X-Macros para permitir que o pré-compilador gere código. Eles são especialmente úteis para definir valores de erro e cadeias de erro associadas em um único local, mas podem ir muito além disso.

Nossa base de código tem um truque semelhante a

#ifdef DEBUG

#define my_malloc(amt) my_malloc_debug(amt, __FILE__, __LINE__)
void * my_malloc_debug(int amt, char* file, int line)
#else
void * my_malloc(int amt)
#endif
{
    //remember file and line no. for this malloc in debug mode
}

que permite o rastreamento de vazamentos de memória no modo de depuração. Eu sempre achei isso legal.

Diversão com macros:

#define SOME_ENUMS(F) \
    F(ZERO, zero) \
    F(ONE, one) \
    F(TWO, two)

/* Now define the constant values.  See how succinct this is. */

enum Constants {
#define DEFINE_ENUM(A, B) A,
    SOME_ENUMS(DEFINE_ENUMS)
#undef DEFINE_ENUM
};

/* Now a function to return the name of an enum: */

const char *ToString(int c) {
    switch (c) {
    default: return NULL; /* Or whatever. */
#define CASE_MACRO(A, B) case A: return #b;
     SOME_ENUMS(CASE_MACRO)
#undef CASE_MACRO
     }
}

Aqui está um exemplo de como tornar o código C completamente inconsciente sobre o que realmente é usado pelo HW para executar o aplicativo. O main.c faz a configuração e, em seguida, a camada livre pode ser implementada em qualquer compilador / arco. Eu acho que é bastante interessante abstrair um pouco o código C, por isso não chega a ser específico.

Adicionando um exemplo compilável completo aqui.

/* free.h */
#ifndef _FREE_H_
#define _FREE_H_
#include <stdio.h>
#include <string.h>
typedef unsigned char ubyte;

typedef void (*F_ParameterlessFunction)() ;
typedef void (*F_CommandFunction)(ubyte byte) ;

void F_SetupLowerLayer (
F_ParameterlessFunction initRequest,
F_CommandFunction sending_command,
F_CommandFunction *receiving_command);
#endif

/* free.c */
static F_ParameterlessFunction Init_Lower_Layer = NULL;
static F_CommandFunction Send_Command = NULL;
static ubyte init = 0;
void recieve_value(ubyte my_input)
{
    if(init == 0)
    {
        Init_Lower_Layer();
        init = 1;
    }
    printf("Receiving 0x%02x\n",my_input);
    Send_Command(++my_input);
}

void F_SetupLowerLayer (
    F_ParameterlessFunction initRequest,
    F_CommandFunction sending_command,
    F_CommandFunction *receiving_command)
{
    Init_Lower_Layer = initRequest;
    Send_Command = sending_command;
    *receiving_command = &recieve_value;
}

/* main.c */
int my_hw_do_init()
{
    printf("Doing HW init\n");
    return 0;
}
int my_hw_do_sending(ubyte send_this)
{
    printf("doing HW sending 0x%02x\n",send_this);
    return 0;
}
F_CommandFunction my_hw_send_to_read = NULL;

int main (void)
{
    ubyte rx = 0x40;
    F_SetupLowerLayer(my_hw_do_init,my_hw_do_sending,&my_hw_send_to_read);

    my_hw_send_to_read(rx);
    getchar();
    return 0;
}

if(---------)  
printf("hello");  
else   
printf("hi");

Preencha os espaços em branco para que nem olá nem olá apareçam na saída.
ans:fclose(stdout)