Was ist Ihr Lieblings-C-Programmiertrick? [geschlossen]

Zum Beispiel bin ich kürzlich im Linux-Kernel darauf gestoßen:

/ * Erzwinge einen Kompilierungsfehler, wenn die Bedingung erfüllt ist * /
#define BUILD_BUG_ON (Bedingung) ((void) sizeof (char [1 - 2 * !! (Bedingung)]))

Wenn Sie also in Ihrem Code eine Struktur haben, die beispielsweise ein Vielfaches von 8 Bytes groß sein muss, möglicherweise aufgrund einiger Hardwareeinschränkungen, können Sie Folgendes tun:

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

und es wird nicht kompiliert, es sei denn, die Größe von struct mystruct ist ein Vielfaches von 8, und wenn es ein Vielfaches von 8 ist, wird überhaupt kein Laufzeitcode generiert.

Ein weiterer Trick, den ich kenne, stammt aus dem Buch "Graphics Gems", mit dem eine einzelne Header-Datei Variablen in einem Modul deklarieren und initialisieren kann, während sie in anderen Modulen, die dieses Modul verwenden, lediglich als extern deklariert werden.

#ifdef DEFINE_MYHEADER_GLOBALS
# GLOBAL definieren
#define INIT (x, y) (x) = (y)
#sonst
#define GLOBAL extern
#define INIT (x, y)
#endif

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

Damit macht der Code, der x und somefunc definiert, Folgendes:

#define DEFINE_MYHEADER_GLOBALS
#include "the_above_header_file.h"

während Code, der lediglich x und somefunc () verwendet, Folgendes tut:

#include "the_above_header_file.h"

Sie erhalten also eine Header-Datei, die sowohl Instanzen von Globals als auch Funktionsprototypen deklariert, wo sie benötigt werden, sowie die entsprechenden externen Deklarationen.

Also, was sind deine Lieblings-C-Programmier-Tricks in dieser Richtung?

C99 bietet einige wirklich coole Sachen mit anonymen Arrays:

Sinnlose Variablen entfernen

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

wird

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

Übergeben einer variablen Anzahl von Argumenten

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

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

Statische verknüpfte Listen

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

Ich bin mir sicher, dass ich an viele andere coole Techniken nicht gedacht habe.

Beim Lesen des Quake 2-Quellcodes habe ich mir Folgendes ausgedacht:

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

(Mehr oder weniger habe ich den Code nicht zur Hand, um ihn jetzt zu überprüfen).

Seitdem öffnete sich vor meinen Augen eine neue Welt des kreativen Einsatzes des Präprozessors. Ich füge nicht mehr nur Header hinzu, sondern ab und zu ganze Codestücke (dies verbessert die Wiederverwendbarkeit erheblich) :-p

Danke John Carmack! xD

Ich verwende gerne = {0};Strukturen, um Strukturen zu initialisieren, ohne memset aufrufen zu müssen.

struct something X = {0};

Dadurch werden alle Elemente der Struktur (oder des Arrays) auf Null initialisiert (jedoch keine Füllbytes - verwenden Sie memset, wenn Sie diese ebenfalls auf Null setzen müssen).

Sie sollten sich jedoch bewusst sein, dass es bei großen, dynamisch zugewiesenen Strukturen einige Probleme gibt .

Wenn wir über C-Tricks sprechen, muss mein Favorit Duffs Gerät zum Abrollen der Schleife sein! Ich warte nur auf die richtige Gelegenheit, damit ich sie tatsächlich im Zorn nutzen kann ...

Verwenden __FILE__und __LINE__zum Debuggen

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

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

Einmal haben ein Freund von mir und ich die Rückkehr neu definiert, um einen kniffligen Fehler bei der Stapelkorruption zu finden.

Etwas wie:

#define return DoSomeStackCheckStuff, return

Ich mag den "Struktur-Hack" für ein dynamisch großes Objekt. Diese Seite erklärt es auch ziemlich gut (obwohl sie sich auf die C99-Version beziehen, in der Sie "str []" als letztes Mitglied einer Struktur schreiben können). Sie könnten einen String "Objekt" wie folgt machen:

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;

Hier haben wir eine Struktur vom Typ X auf dem Heap zugewiesen, die die Größe eines int (für len) plus der Länge von "Hallo Welt" plus 1 hat (da str 1 in der Größe von (X) enthalten ist.

Dies ist im Allgemeinen nützlich, wenn Sie einen "Header" direkt vor einigen Daten variabler Länge im selben Block haben möchten.

Objektorientierter Code mit C durch Emulieren von Klassen.

Erstellen Sie einfach eine Struktur und eine Reihe von Funktionen, die als ersten Parameter einen Zeiger auf diese Struktur verwenden.

Anstatt

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

Verwenden

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

Verwenden eines dummen Makrotricks, um die Pflege von Datensatzdefinitionen zu vereinfachen.

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

Zum Erstellen einer Variablen, die in allen Modulen außer der schreibgeschützten Variablen schreibgeschützt ist:

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

Bitverschiebungen werden nur bis zu einem Verschiebungsbetrag von 31 (auf einer 32-Bit-Ganzzahl) definiert.

Was machen Sie, wenn Sie eine berechnete Schicht haben möchten, die auch mit höheren Schichtwerten arbeiten muss? So macht es der Theora-Videocodec:

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

Oder viel lesbarer:

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

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

Das Ausführen der Aufgabe auf die oben gezeigte Weise ist viel schneller als die Verwendung eines Zweigs wie diesem:

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

Deklarieren von Zeigerarrays auf Funktionen zum Implementieren von Finite-State-Maschinen.

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

Der erfreulichste Vorteil ist, dass es einfach ist, jeden Stimulus / Zustand zu zwingen, alle Codepfade zu überprüfen.

In einem eingebetteten System ordne ich häufig einen ISR zu, um auf eine solche Tabelle zu verweisen, und revektoriere sie nach Bedarf (außerhalb des ISR).

Ein weiterer netter "Trick" vor dem Prozessor besteht darin, das Zeichen "#" zum Drucken von Debugging-Ausdrücken zu verwenden. Beispielsweise:

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

Bearbeiten: Der folgende Code funktioniert nur unter C ++. Vielen Dank an smcameron und Evan Teran.

Ja, die Kompilierungszeit ist immer großartig. Es kann auch geschrieben werden als:

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

Ich würde es nicht wirklich als Lieblingstrick bezeichnen, da ich es nie benutzt habe, aber die Erwähnung von Duffs Gerät erinnerte mich an diesen Artikel über die Implementierung von Coroutines in C. Es gibt mir immer ein Kichern, aber ich bin mir sicher, dass es das könnte irgendwann nützlich sein.

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

Die Weile (0); hat keine Auswirkung auf das Programm, aber der Compiler gibt eine Warnung über "Dies macht nichts" aus. Dies reicht aus, um mich dazu zu bringen, auf die fehlerhafte Zeile zu schauen und dann den wahren Grund zu sehen, warum ich darauf aufmerksam machen wollte.

Ich bin ein Fan von XOR-Hacks:

2 Zeiger ohne dritten temporären Zeiger tauschen:

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

Oder ich mag die xor verknüpfte Liste mit nur einem Zeiger wirklich. (http://en.wikipedia.org/wiki/XOR_linked_list)

Jeder Knoten in der verknüpften Liste ist das X oder des vorherigen Knotens und des nächsten Knotens. Um vorwärts zu fahren, wird die Adresse der Knoten auf folgende Weise gefunden:

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

etc.

oder rückwärts fahren:

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.

Obwohl es nicht besonders nützlich ist (Sie können nicht von einem beliebigen Knoten aus durchqueren), finde ich es sehr cool.

Dieser stammt aus dem Buch 'Genug Seil, um sich in den Fuß zu schießen':

In der Kopfzeile deklarieren

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

Platzieren Sie in Ihrem Code Testanweisungen, z.

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

Das do / while hilft, falls der Inhalt des Makros auf mehrere Anweisungen erweitert wird.

Die Anweisung wird nur gedruckt, wenn das Flag '-D RELEASE' für den Compiler nicht verwendet wird.

Sie können dann z. Übergebe die Flagge an dein Makefile usw.

Ich bin mir nicht sicher, wie das in Windows funktioniert, aber in * nix funktioniert es gut

Rusty produzierte tatsächlich eine ganze Reihe von Build-Bedingungen in ccan erstellt. Schauen Sie sich das Build- Assert- Modul an:

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

Es gibt viele andere hilfreiche Makros im eigentlichen Header, die sich leicht einfügen lassen.

Ich versuche mit aller Kraft, dem Zug der dunklen Seite (und dem Missbrauch durch Präprozessoren) zu widerstehen, indem ich mich hauptsächlich an Inline-Funktionen halte, aber ich mag clevere, nützliche Makros wie die von Ihnen beschriebenen.

Zwei gute Quellenbücher für diese Art von Dingen sind Die Praxis des Programmierens und Schreibens von festem Code . Einer von ihnen (ich weiß nicht mehr, welcher) sagt: Bevorzugen Sie enum gegenüber #define, wo Sie können, da enum vom Compiler überprüft wird.

Nicht spezifisch für C, aber ich habe den XOR-Operator immer gemocht. Eine coole Sache, die es tun kann, ist "Tauschen ohne temporären Wert":

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

Ergebnis:

a = 1, b = 2

a = 2, b = 1

Siehe Frage "Versteckte Funktionen von C" .

Ich mag das Konzept container_of, zum Beispiel in Listen verwendet zu werden. Grundsätzlich müssen Sie nicht angeben , nextundlast Felder für jede Struktur , die in der Liste sein. Stattdessen hängen Sie den Listenstrukturkopf an die tatsächlich verknüpften Elemente an.

Schauen Sie sich include/linux/list.hBeispiele aus der Praxis an.

Ich denke, die Verwendung von Benutzerdatenzeigern ist ziemlich ordentlich. Eine Mode, die heutzutage an Boden verliert. Es ist nicht so sehr eine C-Funktion, aber in C ziemlich einfach zu verwenden.

Ich benutze X-Makros , um den Pre-Compiler Code generieren zu lassen. Sie sind besonders nützlich, um Fehlerwerte und zugehörige Fehlerzeichenfolgen an einer Stelle zu definieren, können jedoch weit darüber hinausgehen.

Unsere Codebasis hat einen ähnlichen Trick wie

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

Dies ermöglicht die Verfolgung von Speicherlecks im Debug-Modus. Ich fand das immer cool.

Spaß mit Makros:

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

Hier ist ein Beispiel, wie Sie C-Code völlig unbewusst machen können, was tatsächlich von HW zum Ausführen der App verwendet wird. Die main.c führt das Setup durch und dann kann die freie Ebene auf jedem Compiler / Arch implementiert werden. Ich denke, es ist ziemlich ordentlich, um C-Code ein wenig zu abstrahieren, so dass es nicht zu spezifisch wird.

Fügen Sie hier ein vollständiges kompilierbares Beispiel hinzu.

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

Füllen Sie die Lücken aus, damit weder Hallo noch Hallo in der Ausgabe erscheinen.
ans:fclose(stdout)