Qual è il tuo trucco di programmazione C preferito? [chiuso]

Ad esempio, di recente mi sono imbattuto in questo nel kernel di Linux:

/ * Forza un errore di compilazione se la condizione è vera * /
#define BUILD_BUG_ON (condition) ((void) sizeof (char [1 - 2 * !! (condition)]))

Quindi, nel tuo codice, se hai una struttura che deve essere, diciamo un multiplo di 8 byte di dimensione, forse a causa di alcuni vincoli hardware, puoi fare:

BUILD_BUG_ON ((sizeof (struct mystruct)% 8)! = 0);

e non verrà compilato a meno che la dimensione di struct mystruct non sia un multiplo di 8 e se si tratta di un multiplo di 8, non viene generato alcun codice di runtime.

Un altro trucco che conosco è dal libro "Graphics Gems" che consente a un singolo file di intestazione di dichiarare e inizializzare le variabili in un modulo mentre in altri moduli che usano quel modulo, semplicemente dichiararle come esterne.

#ifdef DEFINE_MYHEADER_GLOBALS
#define GLOBAL
#define INIT (x, y) (x) = (y)
#altro
#define GLOBAL extern
#define INIT (x, y)
#finisci se

GLOBAL int INIT (x, 0);
GLOBAL int somefunc (int a, int b);

Con ciò, il codice che definisce x e somefunc fa:

#define DEFINE_MYHEADER_GLOBALS
#include "the_above_header_file.h"

mentre il codice che utilizza semplicemente x e somefunc () fa:

#include "the_above_header_file.h"

In questo modo si ottiene un file di intestazione che dichiara sia le istanze dei globuli che i prototipi delle funzioni dove sono necessari e le corrispondenti dichiarazioni esterne.

Quindi, quali sono i tuoi trucchi di programmazione C preferiti in questo senso?

C99 offre alcune cose davvero interessanti usando array anonimi:

Rimozione di variabili inutili

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

diventa

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

Passare una quantità variabile di argomenti

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

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

Elenchi statici collegati

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

Sono sicuro che molte altre tecniche interessanti non ho pensato.

Durante la lettura del codice sorgente di Quake 2 mi è venuta in mente una cosa del genere:

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

(più o meno, non ho il codice a portata di mano per controllarlo ora).

Da allora, un nuovo mondo di uso creativo del preprocessore si è aperto davanti ai miei occhi. Non includo più solo le intestazioni, ma ogni tanto interi pezzi di codice (migliora molto la riusabilità) :-p

Grazie John Carmack! xD

Mi piace usare = {0};l'inizializzazione delle strutture senza dover chiamare memset.

struct something X = {0};

Questo inizializzerà tutti i membri della struttura (o matrice) su zero (ma non sui byte di riempimento: utilizzare memset se è necessario azzerare anche quelli).

Ma dovresti essere consapevole che ci sono alcuni problemi con questo per le grandi strutture allocate dinamicamente .

Se stiamo parlando di trucchi c, il mio preferito deve essere il dispositivo di Duff per lo svolgimento di loop! Sto solo aspettando l'occasione giusta per trovarmi per usarlo davvero con rabbia ...

utilizzando __FILE__e __LINE__per il debug

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

Nel 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};

Una volta un mio compagno e io abbiamo ridefinito il ritorno per trovare un insetto bug corruzione dello stack.

Qualcosa di simile a:

#define return DoSomeStackCheckStuff, return

Mi piace il "trucco hack" per avere un oggetto di dimensioni dinamiche. Questo sito lo spiega anche abbastanza bene (sebbene facciano riferimento alla versione C99 in cui è possibile scrivere "str []" come ultimo membro di una struttura). potresti creare una stringa "oggetto" come questo:

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;

qui, abbiamo allocato una struttura di tipo X sull'heap delle dimensioni di un int (per len), più la lunghezza di "ciao mondo", più 1 (poiché str 1 è incluso nella dimensione di (X).

È generalmente utile quando si desidera avere un "header" proprio prima di alcuni dati di lunghezza variabile nello stesso blocco.

Codice orientato agli oggetti con C, emulando le classi.

Basta creare una struttura e un insieme di funzioni che puntino su quella struttura come primo parametro.

Invece di

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

Uso

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

Usare uno stupido trucco con le macro per rendere più semplice la gestione delle definizioni dei record.

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

Per creare una variabile che è di sola lettura in tutti i moduli tranne quello in cui è dichiarata:

// 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

Gli spostamenti di bit sono definiti solo fino a un valore di spostamento di 31 (su un numero intero di 32 bit).

Cosa fai se vuoi avere un turno calcolato che deve funzionare anche con valori di spostamento più alti? Ecco come funziona il videodecec Theora:

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

O molto più leggibile:

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

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

Eseguire l'attività nel modo indicato sopra è molto più veloce dell'uso di un ramo come questo:

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

Dichiarazione di array di puntatori a funzioni per l'implementazione di macchine a stati finiti.

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

Il vantaggio più piacevole è che è semplice forzare ogni stimolo / stato a controllare tutti i percorsi del codice.

In un sistema incorporato, spesso mapperò un ISR per puntare a tale tabella e lo rivelerò secondo necessità (al di fuori dell'ISR).

Un altro "trucco" pre-processore consiste nell'utilizzare il carattere "#" per stampare espressioni di debug. Per esempio:

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

modificare: il codice seguente funziona solo su C ++. Grazie a smcameron e Evan Teran.

Sì, il tempo di compilazione asserito è sempre eccezionale. Può anche essere scritto come:

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

Non lo definirei un trucco preferito, dal momento che non l'ho mai usato, ma la menzione di Duff's Device mi ha ricordato questo articolo sull'implementazione di Coroutine in C. Mi fa sempre ridere, ma sono sicuro che potrebbe essere utile qualche volta.

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

The while (0); non ha alcun effetto sul programma, ma il compilatore emetterà un avviso su "questo non fa nulla", il che è abbastanza per farmi andare a guardare la linea offensiva e quindi vedere il vero motivo per cui volevo attirare l'attenzione su di esso.

Sono un fan degli hack xor:

Scambia 2 puntatori senza puntatore terza temperatura:

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

O mi piace molto la lista dei link xor con un solo puntatore. (Http://en.wikipedia.org/wiki/XOR_linked_list)

Ogni nodo nell'elenco collegato è lo Xor del nodo precedente e del nodo successivo. Per spostarsi in avanti, l'indirizzo dei nodi si trova nel modo seguente:

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

eccetera.

o per attraversare all'indietro:

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;

eccetera.

Sebbene non sia terribilmente utile (non puoi iniziare a spostarti da un nodo arbitrario) lo trovo molto interessante.

Questo è tratto dal libro "Abbastanza corda per spararti ai piedi":

Nell'intestazione dichiarare

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

Nel codice inserire dichiarazioni di test, ad esempio:

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

Il do / while aiuta nel caso in cui il contenuto della macro si espanda a più istruzioni.

L'istruzione verrà stampata solo se non viene utilizzato il flag '-D RELEASE' per il compilatore.

È quindi possibile ad es. passa la bandiera al tuo makefile ecc.

Non sono sicuro di come funzioni in Windows, ma in * nix funziona bene

Rusty ha effettivamente prodotto un intero set di condizionali build in ccan , controlla il modulo assert build:

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

Ci sono molte altre macro utili nell'intestazione reale, che sono facili da inserire.

Cerco, con tutte le mie forze, di resistere all'attrazione del lato oscuro (e dell'abuso del preprocessore) attenendomi principalmente alle funzioni incorporate, ma mi piacciono le macro intelligenti e utili come quelle che hai descritto.

Due buoni libri di riferimento per questo genere di cose sono The Practice of Programming and Writing Solid Code . Uno di questi (non ricordo quale) dice: Preferisci enum a #define dove puoi, perché enum viene controllato dal compilatore.

Non specifico per C, ma mi è sempre piaciuto l'operatore XOR. Una cosa interessante che può fare è "scambiare senza un valore temporaneo":

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

Risultato:

a = 1, b = 2

a = 2, b = 1

Vedi la domanda "Funzioni nascoste di C" .

Mi piace il concetto di container_ofusato ad esempio negli elenchi. Fondamentalmente, non è necessario specificare nexte lastcampi per ogni struttura che sarà nell'elenco. Invece, si aggiunge l'intestazione della struttura dell'elenco agli elementi effettivamente collegati.

Dai un'occhiata include/linux/list.hagli esempi di vita reale.

Penso che l'uso dei puntatori userdata sia piuttosto accurato. Una moda che perde terreno oggi. Non è tanto una caratteristica C ma è abbastanza facile da usare in C.

Uso X-Macros per consentire al pre-compilatore di generare codice. Sono particolarmente utili per definire i valori di errore e le stringhe di errore associate in un unico punto, ma possono andare ben oltre.

La nostra base di codice ha un trucco simile 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
}

che consente il tracciamento delle perdite di memoria in modalità debug. Ho sempre pensato che fosse bello.

Divertimento con le macro:

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

Ecco un esempio di come rendere il codice C completamente ignaro di ciò che viene effettivamente utilizzato da HW per l'esecuzione dell'app. Il main.c esegue l'installazione e quindi il layer libero può essere implementato su qualsiasi compilatore / arco. Penso che sia abbastanza pulito per sottrarre un po 'il codice C, quindi non può essere troppo specifico.

Aggiungendo un esempio compilabile completo qui.

/* 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");

Riempi gli spazi vuoti in modo che né ciao né ciao compaiano in output.
ans:fclose(stdout)