Die nützlichsten benutzerdefinierten C-Makros (in GCC, auch C99)? [closed]

Was C Makro ist Ihrer Meinung nach das nützlichste? Ich habe das folgende gefunden, in dem ich Vektorarithmetik mache C:

#define v3_op_v3(x, op, y, z) {z[0]=x[0] op y[0]; \
                               z[1]=x[1] op y[1]; \
                               z[2]=x[2] op y[2];}

Es funktioniert so:

v3_op_v3(vectorA, +, vectorB, vectorC);
v3_op_v3(vectorE, *, vectorF, vectorJ);
...

#define IMPLIES(x, y) (!(x) || (y))

#define COMPARE(x, y) (((x) > (y)) - ((x) < (y)))
#define SIGN(x) COMPARE(x, 0)

#define ARRAY_SIZE(a) (sizeof(a) / sizeof(*a))

#define SWAP(x, y, T) do { T tmp = (x); (x) = (y); (y) = tmp; } while(0)
#define SORT2(a, b, T) do { if ((a) > (b)) SWAP((a), (b), T); } while (0)

#define SET(d, n, v) do{ size_t i_, n_; for (n_ = (n), i_ = 0; n_ > 0; --n_, ++i_) (d)[i_] = (v); } while(0)
#define ZERO(d, n) SET(d, n, 0)

Und natürlich diverse MIN, MAX, ABS etc.

Beachten Sie übrigens, dass keines der oben genannten Elemente durch eine Funktion in C implementiert werden kann.

PS Ich würde wahrscheinlich das oben genannte hervorheben IMPLIES Makro als eines der nützlichsten. Sein Hauptzweck besteht darin, das Schreiben eleganterer und lesbarer Behauptungen zu erleichtern, wie z

void foo(int array[], int n) {
  assert(IMPLIES(n > 0, array != NULL));
  ...

Der entscheidende Punkt bei C-Makros ist ihre richtige Verwendung. Meiner Meinung nach gibt es drei Kategorien (ohne in Betracht zu ziehen, sie nur zu verwenden, um Konstanten beschreibende Namen zu geben).

1. Als Abkürzung für Codes, die man nicht wiederholen möchte
2. Stellen Sie eine allgemeine Verwendungsfunktion bereit
3. Ändern Sie die Struktur der C-Sprache (anscheinend)

Im ersten Fall lebt Ihr Makro nur in Ihrem Programm (normalerweise nur eine Datei), sodass Sie Makros wie das von Ihnen gepostete verwenden können, das nicht gegen doppelte Auswertung von Parametern und Verwendungen geschützt ist {...}; (potenziell gefährlich!).

Im zweiten Fall (und noch mehr im dritten) müssen Sie es sein äußerst Achten Sie darauf, dass sich Ihre Makros korrekt verhalten, als wären sie echte C-Konstrukte.

Das Makro, das Sie von GCC (min und max) gepostet haben, ist ein Beispiel dafür, sie verwenden die globalen Variablen _a und _b um das Risiko einer Doppelbewertung zu vermeiden (wie in max(x++,y++)) (Nun, sie verwenden GCC-Erweiterungen, aber das Konzept ist dasselbe).

Ich verwende Makros gerne, wenn es hilft, die Dinge klarer zu machen, aber sie sind ein scharfes Werkzeug! Wahrscheinlich haben sie deshalb einen so schlechten Ruf, ich denke, sie sind ein sehr nützliches Werkzeug und C wäre viel schlechter gewesen, wenn sie nicht vorhanden wären.

Ich sehe, dass andere Beispiele für Punkt 2 (Makros als Funktionen) bereitgestellt haben, lassen Sie mich ein Beispiel für die Erstellung eines neuen C-Konstrukts geben: die endliche Zustandsmaschine. (Ich habe dies bereits auf SO gepostet, aber ich kann es anscheinend nicht finden)

 #define FSM            for(;;)
 #define STATE(x)       x##_s 
 #define NEXTSTATE(x)   goto x##_s

die Sie so verwenden:

 FSM {
    STATE(s1):
      ... do stuff ...
      NEXTSTATE(s2);

    STATE(s2):
      ... do stuff ...
      if (k<0) NEXTSTATE(s2); 
      /* fallthrough as the switch() cases */

    STATE(s3):
      ... final stuff ...
      break;  /* Exit from the FSM */
 } 

Sie können Variationen zu diesem Thema hinzufügen, um den Geschmack von FSM zu erhalten, den Sie benötigen.

Jemand mag dieses Beispiel nicht mögen, aber ich finde es perfekt, um zu demonstrieren, wie einfache Makros Ihren Code lesbarer und aussagekräftiger machen können.

for-each-Schleife in C99:

#define foreach(item, array) \
    for(int keep=1, \
            count=0,\
            size=sizeof (array)/sizeof *(array); \
        keep && count != size; \
        keep = !keep, count++) \
      for(item = (array)+count; keep; keep = !keep)

int main() {
  int a[] = { 1, 2, 3 };
  int sum = 0;
  foreach(int const* c, a)
    sum += *c;
  printf("sum = %d\n", sum);

  // multi-dim array
  int a1[][2] = { { 1, 2 }, { 3, 4 } };
  foreach(int (*c1)[2], a1)
    foreach(int *c2, *c1) 
      printf("c2 = %d\n", *c2);
}

Wenn Sie Daten mehrmals in verschiedenen Kontexten definieren müssen, können Makros Ihnen dabei helfen, zu vermeiden, dass Sie dasselbe mehrmals neu auflisten müssen.

Angenommen, Sie möchten eine Aufzählung von Farben und eine Aufzählung-zu-String-Funktion definieren, anstatt alle Farben zweimal aufzulisten, könnten Sie eine Datei mit den Farben erstellen (Farben.def):

c(red)
c(blue)
c(green)
c(yellow)
c(brown)

Jetzt können Sie in Ihrer c-Datei Ihre Enum- und Ihre String-Konvertierungsfunktion definieren:

enum {
#define c(color) color,
# include "colors.def"
#undef c
};

const char *
color_to_string(enum color col)
{
    static const char *colors[] = {
#define c(color) #color,
# include "colors.def"
#undef c
    };
    return (colors[col]);
};

#if defined NDEBUG
    #define TRACE( format, ... )
#else
    #define TRACE( format, ... )   printf( "%s::%s(%d)" format, __FILE__, __FUNCTION__,  __LINE__, __VA_ARGS__ )
#endif

Beachten Sie das Fehlen eines Kommas zwischen "%s::%s(%d)" und format ist absichtlich. Es gibt eine formatierte Zeichenfolge mit vorangestelltem Quellspeicherort aus. Ich arbeite in Echtzeit-Embedded-Systemen, so oft füge ich auch einen Zeitstempel in die Ausgabe ein.

Foreach-Schleife für GCC, insbesondere C99 mit GNU-Erweiterungen. Funktioniert mit Strings und Arrays. Dynamisch zugewiesene Arrays können verwendet werden, indem sie in einen Zeiger auf ein Array umgewandelt und dann dereferenziert werden.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

#define FOREACH_COMP(INDEX, ARRAY, ARRAY_TYPE, SIZE) \
  __extension__ \
  ({ \
    bool ret = 0; \
    if (__builtin_types_compatible_p (const char*, ARRAY_TYPE)) \
      ret = INDEX < strlen ((const char*)ARRAY); \
    else \
      ret = INDEX < SIZE; \
    ret; \
  })

#define FOREACH_ELEM(INDEX, ARRAY, TYPE) \
  __extension__ \
  ({ \
    TYPE *tmp_array_ = ARRAY; \
    &tmp_array_[INDEX]; \
  })

#define FOREACH(VAR, ARRAY) \
for (void *array_ = (void*)(ARRAY); array_; array_ = 0) \
for (size_t i_ = 0; i_ && array_ && FOREACH_COMP (i_, array_, \
                                    __typeof__ (ARRAY), \
                                    sizeof (ARRAY) / sizeof ((ARRAY)[0])); \
                                    i_++) \
for (bool b_ = 1; b_; (b_) ? array_ = 0 : 0, b_ = 0) \
for (VAR = FOREACH_ELEM (i_, array_, __typeof__ ((ARRAY)[0])); b_; b_ = 0)

/* example's */
int
main (int argc, char **argv)
{
  int array[10];
  /* initialize the array */
  int i = 0;
  FOREACH (int *x, array)
    {
      *x = i;
      ++i;
    }

  char *str = "hello, world!";
  FOREACH (char *c, str)
    printf ("%c\n", *c);

  /* Use a cast for dynamically allocated arrays */
  int *dynamic = malloc (sizeof (int) * 10);
  for (int i = 0; i < 10; i++)
    dynamic[i] = i;

  FOREACH (int *i, *(int(*)[10])(dynamic))
    printf ("%d\n", *i);

  return EXIT_SUCCESS;
}

Dieser Code wurde getestet, um mit GCC, ICC und Clang unter GNU/Linux zu funktionieren.

Lambda-Ausdrücke (nur GCC)

#define lambda(return_type, ...) \
  __extension__ \
  ({ \
    return_type __fn__ __VA_ARGS__ \
    __fn__; \
  })

int
main (int argc, char **argv)
{
  int (*max) (int, int) = 
    lambda (int, (int x, int y) { return x > y ? x : y; });
  return max (1, 2);
}

Jemand anderes erwähnte container_of(), lieferte aber keine Erklärung für dieses wirklich praktische Makro. Nehmen wir an, Sie haben eine Struktur, die so aussieht:

struct thing {
    int a;
    int b;
};

Nun, wenn wir einen Zeiger auf haben bwir können benutzen container_of() um einen Zeiger zu bekommen Ding typsicher:

int *bp = ...;
struct thing *t = container_of(bp, struct thing, b);

Dies ist nützlich, um abstrakte Datenstrukturen zu erstellen. Anstatt beispielsweise den Ansatz zu verwenden, den queue.h zum Erstellen von Dingen wie SLIST (Tonnen verrückter Makros für jede Operation) verwendet, können Sie jetzt eine Slist-Implementierung schreiben, die ungefähr so ​​​​aussieht:

struct slist_el {
    struct slist_el *next;
};

struct slist_head {
    struct slist_el *first;
};

void
slist_insert_head(struct slist_head *head, struct slist_el *el)
{
    el->next = head->first;
    head->first = el;
}

struct slist_el
slist_pop_head(struct slist_head *head)
{
    struct slist_el *el;

    if (head->first == NULL)
        return NULL;

    el = head->first;
    head->first = el->next;
    return (el);   
}

Was kein verrückter Makrocode ist. Es gibt gute Compiler-Zeilennummern bei Fehlern und funktioniert gut mit dem Debugger. Es ist auch ziemlich typsicher, außer in Fällen, in denen Strukturen mehrere Typen verwenden (z. B. wenn wir es erlaubt haben Strukturfarbe im folgenden Beispiel, um auf mehr verknüpften Listen als nur der zu sein Farben eines).

Benutzer können Ihre Bibliothek jetzt wie folgt verwenden:

struct colors {
    int r;
    int g;
    int b;
    struct slist_el colors;
};

struct *color = malloc(sizeof(struct person));
color->r = 255;
color->g = 0;
color->b = 0;
slist_insert_head(color_stack, &color->colors);
...
el = slist_pop_head(color_stack);
color = el == NULL ? NULL : container_of(el, struct color, colors);