`#define`-Direktive

Mittels der #define-Direktive wird einem Namen ein Makro zugewiesen, welches im gesamten darauf folgenden Code den Namen ersetzt. Makros können Parameter besitzen, und somit im Code ähnlich wie Funktionen aufgerufen werden. Der Gebrauch solcher Makros ist jedoch heimtückisch.









PI = 3.140000
I love ManderC
Hypothenuse = 5.00

#include <stdio.h>
#include <math.h>

#define PI 3.14
#define TRUE_LOVE "ManderC"
#define PYTHAGORAS(a,b) sqrt(a*a+b*b)

int main(){
  printf("PI = %f\n", PI);
  printf("I love %s\n", TRUE_LOVE);
  printf("Hypothenuse = %1.2f\n", PYTHAGORAS(3,4));
  return 0;
}

Details

Ein Makro ist grundsätzlich nichts anderes als ein Text-Schnipsel, welcher beim Compilieren in einem Vorverarbeitungs-Schritt (Pre-processing) mittels einfacher Ersetzung an die Stellen kopiert wird, wo der Name des Makros auftritt. Mit Ausnahme von bestimmten Preprozessor-Operatoren und eventuellen Makro-Parametern werden einfach jegliche Zeichen (inklusive Whitespaces) des bei der #define-Direktive angegebenen Texts eins-zu-eins kopiert und daraufhin vom eigentlichen Compiler abgearbeitet.

Makros sind sehr gut geeignet für allgemeingültige Konstanten wie Pi, e, Wurzel-2, die Erdanziehungskraft g und ähnliche. Solche unveränderbare konstante Werte sind insofern bevorzugt als Makros zu definieren, da sie nicht wie eine Variable während dem Programmablauf erst aus dem Speicher gelesen werden müssen, sondern direkt im Programmcode compiliert sind.

Makros können das Schreiben von repetitivem Programmcode vereinfachen, da sie an fast jeder beliebigen Stelle eingesetzt werden können und somit mühselige Schreibarbeit verhindern.

Des weiteren werden Makros oftmals zur bedingten Compilierung verwendet, beispielsweise mit Flags wie #define USE_ACCURATE_METHOD 1. Wenn der Name eines Makros nicht definiert ist, so wird jegliche Nutzung in einer Preprozessor-Bedingung zu 0 auswerten. Wenn ein nicht-definiertes Makro im zu übersetzenden Code verwendet wird, so meldet der Compiler einen Fehler.

Makros werden immer erst dann ausgewertet, wenn sie gebraucht werden, jedes Mal von neuem:


UNDEFINED_NUMBER

42

#define FOURTY_TWO UNDEFINED_NUMBER
FOURTY_TWO
#define UNDEFINED_NUMBER 42
FOURTY_TWO

Makros werden üblicherweise mit GROSSBUCHSTABEN geschrieben. Des weiteren wird empfohlen, möglichst kleine, überschaubare Makros zu schreiben. Ein Makro muss in einer einzelnen Zeile definiert werden. Mehrzeilige Makros können mittels einem Backslash \ am Ende der Zeile erreicht werden.

Makros sind nicht unproblematisch! Weiter unten werden einige Beispiele gegeben, wo Fehlerquellen liegen und wie Makros aufgrund dessen möglichst sicher geschrieben werden können.

Parametrisierte Makros

Makros können ähnlich wie Funktionen Parameter definieren. Hierzu muss direkt hinter dem Makro-Namen eine durch Komma , getrennte Liste von Parameternamen in runden Klammern () folgen. Zwischen dem Makro-Namen und der öffnenden runden Klammer darf kein Whitespace sein! Parametrisierte Makros können mit den Auslassungspunkten ... auch beliebig viele Parameter besitzen.

Bei Auftreten eines parametrisierten Makros wird der Preprozessor den Makro-Text wie oben beschrieben an die aufgetretene Stelle kopieren, daraufhin jedoch noch zusätzlich sämtliche Parameternamen durch die entsprechenden übergebenen Argumente ersetzen. Im folgenden Beispiel steht links die Ausgabe des Preprozessors:


printf("%d\n", 6*7);

#define MULTIPLY(x, y) x*y
printf("%d\n", MULTIPLY(6, 7));

Es ist zu beachten, dass ein Makro-Argument nicht wie bei einer Funktion einen Wert darstellt, sondern ein beliebiger Text sein kann. Der Preprozessor wird somit blind die Parameter durch die Argumente übersetzen und übergibt das Resultat schlussendlich dem Compiler.

printf("%d\n", 3+3*7);

printf("%d\n", MULTIPLY(3+3, 7));

Wie soeben in diesem Beispiel gezeigt, können aufgrund der blinden Ersetzung von Makros und deren Parameter viele Probleme auftreten. Weiter unten werden einige wichtige Fehlerquellen erläutert.

Makro-Argumente mit Nebeneffekten

Der Gebrauch von Makros mit Argumenten gilt im allgemeinen als unschön und ist entsprechend nicht überall gleich beliebt. Oftmals geht vergessen, dass Makros nicht wie Variablen oder Funktionen ausgelesen oder aufgerufen werden, sondern durch den Preprozessor Zeichen für Zeichen direkt in den Programmcode hineingeschrieben werden. Folgendes Programm verdeutlicht die Problematik:









520932930, 520932930
28925691, 822784415

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

void print_twice(int v){ printf("%d, %d\n", v, v);}
#define PRINT_TWICE(v)   printf("%d, %d\n", v, v)

int main(){
  srand(0);
  print_twice(rand());
  PRINT_TWICE(rand());
  return 0;
}

Während bei der ersten Variante zweimal derselbe Wert ausgegeben wird, werden bei der Makro-Variante zwei verschiedene Werte ausgegeben, obschon das Makro und die Funktion denselben Code definieren. Der Unterschied besteht darin, dass bei der ersten Variante zuerst die Funktion rand() aufgerufen wird und das Resultat (Eine Zufallszahl) als Argument an die Funktion übergeben wird. Bei der Makro-Definition hingegen wird der Code rand() selbst übergeben, was der Preprozessor schlussendlich in folgende Zeile umwandelt:

printf("%d, %d\n", rand(), rand());

Dies bedeutet, dass rand() zweimal aufgerufen wird. Die rand-Funktion hat jedoch einen Nebeneffekt: Bei jedem Aufruf wird eine versteckte Variable verändert. So verändert sich auch das ausgegebene Resultat.

Wann immer somit Makro-Parameter mehrfach im Makro-Text vorkommen, so werden auch die entsprechenden Nebeneffekte eines Ausdruck mehrfach ausgeführt. Dummerweise ist es genauso schwierig, keine Argumente mit Nebeneffekt zu verwenden, wie Makros zu schreiben, bei welchen die Parameter garantiert nicht mehrfach im Makro-Text vorkommen. Glücklicherweise treten entsprechende Fehler eher selten auf. Die Empfehlung des Autors ist, komplizierte Makros spätestens im Falle eines Fehlers durch eine entsprechende Funktion (möglicherweise mit dem inline-Keyword) zu ersetzen.

Weitere Beispiele für Ausdrücke mit Nebeneffekten sind Zuweisungen oder die Inkrement- und Dekrement-Operatoren. Weitere Erläuterungen dazu können bei den Sequenz-Punkten nachgelesen werden.

Direktiven als Makros

Makros können keine weiteren Direktiven enthalten. Sowohl das führende #, als auch der Name der Direktive werden durch den Preprozessor nicht aufgelöst:

expected unqualified-id
before '#' token

#define DEFINE_PI #define PI 3.14
DEFINE_PI

Der Fehler, der hierbei entsteht, ist verwirrend. Er entsteht durch den Compiler, nicht durch den Preprozessor. Das obige Beispiel wird in folgende Zeile übersetzt:

#define PI 3.14

Daraufhin jedoch beendet der Preprozessor seinen Dienst und übergibt diesen Code an den eigentlichen Compiler, der mit dem # nichts anfangen kann.

Das überzählige Semikolon ;

Da der Preprozessor Zeichen für Zeichen umwandelt, ist es nicht notwendig, ein Makro mit einem Semikolon ; abzuschliessen, wenn der Ausdruck im eigentlichen Code wie eine Funktion aussehen soll.




sqrt(3*3 +4*4);;
sqrt(3*3 +4*4);

#define PYTHAGORAS_1(a,b) sqrt(a*a+b*b);
#define PYTHAGORAS_2(a,b) sqrt(a*a+b*b)

PYTHAGORAS_1(3,4);
PYTHAGORAS_2(3,4);

Diese Massnahme sieht in diesem Beispiel aus wie eine unwichtige Schönheits-Korrektur. Wenn jedoch ebendieses Makro nicht als alleinstehende Anweisung, sondern als Teil eines Ausdruckes geschrieben wird, so ist das zusätzliche Semikolon sogar äusserst problematisch, da das Semikolon in den Ausdruck mit hineinkopiert wird, was zu einem Syntax-Fehler führt:

error

printf("%f", sqrt(3*3 +4*4););

Des weiteren gibt es im Zusammenhang mit Makros noch ein Phänomen, welches als Verschluckung des Semikolons bezeichnet wird. Es hat damit zu tun, dass vor einem else-Keyword einer einzeiligen if-Bedingung ein Makro geschrieben wird, welches als ein Code-Block ausprogrammiert ist. Folgendes Beispiel illustriert dies:












Error

#include <stdio.h>

#define CLIP_TO_CENTS(x) {x*=100.; x = (double)(int)x; x/=100.;}
#define CLIP_TO_5CENTS(x) {x*=20.; x = (double)(int)x; x/=20.;}

int main(){
  double mybankaccount = 5624.4736;
  
  int useswisscurrency = 1;
  if(useswisscurrency)
    CLIP_TO_5CENTS(mybankaccount);
  else
    CLIP_TO_CENTS(mybankaccount);

  printf("%f\n", mybankaccount);
  return 0;
}

Hierbei wurde angenommen, dass das Makro ähnlich wie eine Anweisung stets mit einem Semikolon abgeschlossen werden kann. Durch die schliessende geschweifte Klammer des Makros wurde jedoch der if-Teil syntaktisch bereits abgeschlossen. Die C-Syntax erwartet nun entweder das else-Keyword oder aber eine neue Anweisung. Durch die zusätzliche Angabe des Semikolons nimmt der Compiler letzteres an und betrachtet die if-Anweisung als abgeschlossen. Daraufhin findet er ein else ohne ein dazugehöriges if und meldet einen Fehler.

Um den Fehler zu beheben, muss entweder das Semikolon entfernt werden, oder das Makro muss so programmiert werden, dass es das nachfolgende Semikolon verschluckt. Üblicherweise wird dies durch folgendes Konstrukt gelöst:

#define CLIP_TO_5CENTS(x) do {x*=20.; x = (double)(int)x; x/=20.;} while(0)

Die Implementation des Makros befindet sich dadurch immer noch in einem Block, ist aufgrund der do-while-Schleife jedoch als Kontrollstruktur realisiert, welche stets ein Semikolon am Ende erwartet. Mit der Abbruchbedingung 0 wird garantiert, dass die Schleife genau ein einziges Mal durchläuft. Der Compiler wird diese Konstruktion schlussendlich herausoptimieren.

Klammerung von Berechnungen

Für den Preprozessor oder Compiler gibt es feste Regeln, in welcher Reihenfolge Operanden umgesetzt werden. Diese Reihenfolge kann unter anderem mit Klammerung gesteuert werden. Bei Makros wird empfohlen, um Berechnungen herum stets Klammern zu setzen. Folgendes Beispiel zeigt, was passiert, wenn eine Berechnung nicht korrekt geklammert wird:






1 / PI_HALF: 0.159236
1 / PI_HALF: 0.636943

#include <stdio.h>
#define PI_HALF_1  3.14/2.0
#define PI_HALF_2 (3.14/2.0)

int main(){
  printf("1 / PI_HALF: %f\n",  1. / PI_HALF_1);
  printf("1 / PI_HALF: %f\n",  1. / PI_HALF_2);
  return 0;
}

Der Preprozessor übersetzt den Code in die folgenden Zeilen:

printf("1 / PI_HALF: %f\n", 1. /  3.14/2.0 );
printf("1 / PI_HALF: %f\n", 1. / (3.14/2.0));

In der ersten Zeile wird zuerst 1 / PI gerechnet und danach das Resultat durch 2 geteilt. Korrekt wäre jedoch, dass wie in der zweiten Zeile zuerst PI / 2 berechnet wird, und vom Resultat dann der Kehrwert genommen wird.

Klammerung von Casts

Oftmals werden in Makros explizite Casts gemacht. In den allermeisten Fällen werden damit keine Probleme auftreten, allerdings zeigt folgendes Programm ein einfaches Beispiel dessen, was passieren könnte:









Int of 1.5 + 1.5 is 2.50

Int of 1.5 + 1.5 is 3.00

#include <stdio.h>
#define INTEGRAL_1(x) (int) x
#define INTEGRAL_2(x) (int)(x)

int main(){
  float a = 1.5;
  float d;
  d = INTEGRAL_1(a + 1.5f);
  printf("Int of 1.5 + 1.5 is %1.2f\n", d);
  d = INTEGRAL_2(a + 1.5f);
  printf("Int of 1.5 + 1.5 is %1.2f\n", d);
  return 0;
}

Die beiden Zeilen mit der Berechnung werden vom Preprozessor folgendermassen umgewandelt:

d = (int) a + 1.5f;
d = (int)(a + 1.5f);

Damit ist klar, dass bei der ersten Zeile nur a gecastet wird, wohingegen auf der zweiten Zeile die gesamte Berechnung a + 1.5 in einen Integer umgewandelt wird.

Die Fehler bei vergessener Klammerung von Casts können noch schlimmer ausfallen, sobald sie im Zusammenhang mit Pointer-Umwandlungen gebraucht werden, das Programm kann hierbei sogar abstürzen. es ist zu empfehlen, um das gesamte Makro zusätzliche Klammern hinzuzufügen. Folgendes Beispiel versucht, ein zweidimensionales Array als eindimensionales zu casten:








Number: -1073743256
Number: -1073743256
Number: 2

#include <stdio.h>
#define CASTING_1(x)  (int*) x
#define CASTING_2(x)  (int*)(x)
#define CASTING_3(x) ((int*)(x))

int main(){
  int a[3][3] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
  printf("Number: %i\n", CASTING_1(a)[1]);
  printf("Number: %i\n", CASTING_2(a)[1]);
  printf("Number: %i\n", CASTING_3(a)[1]);
  return 0;
}

Die Zeilen werden vom Preprozessor folgendermassen umgewandelt:

printf("Number: %i\n",  (int*) a  [1]);
printf("Number: %i\n",  (int*)(a) [1]);
printf("Number: %i\n", ((int*)(a))[1]);

Während in den ersten beiden Zeilen strickt nach der von der Programmiersprache vorgegebenen Operatorenreihenfolge zuerst das Element mit Index [1] angesprochen und danach fälschlicherweise dereferenziert wird (was zu einer Zahl im Nirvana des unbenutzten Speichers führt), wird erst in der dritten Zeile korrekterweise das Array zuerst als eindimensionales Array gecastet und danach das Element mit Index [1] angesprochen.

Klammerung von Dereferenzen

Folgendes Beispiel zeigt, was passiert, wenn eine Dereferenzierung nicht korrekt geklammert wird:







Number: 2
Number: 4

#include <stdio.h>
#define VALUE_1 (*numbers)
#define VALUE_2  *numbers

int main(){
  int numbers[3][3] = {1,2,3,4,5,6,7,8,9};
  printf("Number: %d\n", VALUE_1[1]);
  printf("Number: %d\n", VALUE_2[1]);
  return 0;
}