Replacing text macros

Der Präprozessor unterstützt Text-Makroersetzung und funktionsähnliche Text-Makroersetzung.

Syntax

Erklärung

#define Direktiven

Die #define Direktiven definieren den identifier als ein Macro, das heißt sie weisen den Compiler an, alle nachfolgenden Vorkommen von identifier durch replacement-list zu ersetzen, was optional zusätzlich verarbeitet werden kann. Wenn der identifier bereits als irgendeine Art von Macro definiert ist, ist das Programm fehlerhaft, es sei denn die Definitionen sind identisch.

Objektartige Makros

Objektartige Makros ersetzen jedes Vorkommen eines definierten identifier durch replacement-list . Version (1) der #define -Direktive verhält sich genau so.

Funktionsartige Makros

Funktionsartige Makros ersetzen jedes Vorkommen eines definierten identifier durch replacement-list , wobei zusätzlich eine Anzahl von Argumenten übernommen wird, die dann entsprechende Vorkommen der parameters in der replacement-list ersetzen.

Die Syntax eines funktionsähnlichen Makroaufrufs ähnelt der Syntax eines Funktionsaufrufs: Jedes Vorkommen des Makronamens, gefolgt von einer ( als nächstes Präprozessor-Token, leitet die Sequenz von Tokens ein, die durch die Ersetzungsliste ersetzt wird. Die Sequenz wird durch das entsprechende ) Token beendet, wobei dazwischenliegende passende Paare von linken und rechten Klammern übersprungen werden.

Die Anzahl der Argumente muss mit der Anzahl der Argumente in der Makrodefinition ( parameters ) übereinstimmen, andernfalls ist das Programm fehlerhaft. Wenn der Bezeichner nicht in Funktionsschreibweise vorliegt, d.h. keine Klammern nach sich hat, wird er überhaupt nicht ersetzt.

Version (2) der #define -Direktive definiert ein einfaches funktionsähnliches Makro.

Version (3) der #define Direktive definiert einen funktionsähnlichen Makro mit variabler Anzahl an Argumenten. Die zusätzlichen Argumente können mittels des __VA_ARGS__ Identifikators zugänglich gemacht werden, welcher anschließend durch die Argumente ersetzt wird, die mit dem zu ersetzenden Identifikator bereitgestellt werden.

Version (4) der #define Direktive definiert ein funktionsähnliches Makro mit variabler Anzahl an Argumenten, jedoch ohne reguläre Argumente. Die Argumente können nur mit dem __VA_ARGS__ Bezeichner zugegriffen werden, der dann durch die Argumente ersetzt wird, die mit dem zu ersetzenden Bezeichner bereitgestellt werden.

#define F(...) f(0 __VA_OPT__(,) __VA_ARGS__)
F(a, b, c) // replaced by f(0, a, b, c)
F()        // replaced by f(0)
#define G(X, ...) f(0, X __VA_OPT__(,) __VA_ARGS__)
G(a, b, c) // replaced by f(0, a, b, c)
G(a, )     // replaced by f(0, a)
G(a)       // replaced by f(0, a)
#define SDEF(sname, ...) S sname __VA_OPT__(= { __VA_ARGS__ })
SDEF(foo);       // replaced by S foo;
SDEF(bar, 1, 2); // replaced by S bar = { 1, 2 };

Hinweis: Wenn ein Argument eines funktionsähnlichen Makros Kommas enthält, die nicht durch passende Paare von linken und rechten Klammern geschützt sind (wie z.B. macro ( array [ x = y, x + 1 ] ) oder atomic_store ( p, ( struct S ) { a, b } ) ; ), wird das Komma als Makroargument-Trennzeichen interpretiert, was zu einem Kompilierungsfehler aufgrund von Argumentanzahl-Ungleichheit führt.

# und ## Operatoren

In funktionsähnlichen Makros führt ein # Operator vor einem Bezeichner in der replacement-list dazu, dass der Bezeichner durch Parameterersetzung verarbeitet und das Ergebnis in Anführungszeichen gesetzt wird, wodurch effektiv ein String-Literal erzeugt wird. Zusätzlich fügt der Präprozessor Backslashes hinzu, um die Anführungszeichen um eingebettete String-Literale zu escapen, falls vorhanden, und verdoppelt die Backslashes innerhalb des Strings nach Bedarf. Alle führenden und nachfolgenden Leerzeichen werden entfernt, und jede Abfolge von Leerzeichen in der Mitte des Textes (aber nicht innerhalb eingebetteter String-Literale) wird auf ein einzelnes Leerzeichen reduziert. Dieser Vorgang wird "Stringifizierung" genannt. Wenn das Ergebnis der Stringifizierung kein gültiges String-Literal ist, ist das Verhalten undefiniert.

#define showlist(...) puts(#__VA_ARGS__)
showlist();            // expands to puts("")
showlist(1, "x", int); // expands to puts("1, \"x\", int")

Ein ## -Operator zwischen zwei aufeinanderfolgenden Bezeichnern in der replacement-list führt eine Parameterersetzung für die beiden Bezeichner durch und verkettet dann das Ergebnis. Dieser Vorgang wird "Konkatenation" oder "Token-Pasting" genannt. Nur Token, die zusammen ein gültiges Token bilden, dürfen verknüpft werden: Bezeichner, die einen längeren Bezeichner bilden, Ziffern, die eine Zahl bilden, oder Operatoren + und = , die einen += bilden. Ein Kommentar kann nicht durch Verknüpfen von / und * erstellt werden, da Kommentare aus dem Text entfernt werden, bevor die Makroersetzung berücksichtigt wird. Wenn das Ergebnis der Konkatenation kein gültiges Token ist, ist das Verhalten undefiniert.

Hinweis: Einige Compiler bieten eine Erweiterung an, die es erlaubt, dass ## nach einem Komma und vor __VA_ARGS__ erscheint, wobei das ## in diesem Fall nichts bewirkt, wenn __VA_ARGS__ nicht leer ist, aber das Komma entfernt, wenn __VA_ARGS__ leer ist: Dies ermöglicht die Definition von Makros wie fprintf ( stderr , format, ##__VA_ARGS__) .

Die Reihenfolge der Auswertung der # - und ## -Operatoren ist nicht spezifiziert.

#undef Direktive

Die #undef -Direktive hebt die Definition des Bezeichners auf, das heißt, sie macht die vorherige Definition des Bezeichners durch die #define -Direktive rückgängig. Wenn der Bezeichner kein assoziiertes Makro besitzt, wird die Direktive ignoriert.

Vordefinierte Makros

Die folgenden Makronamen sind in jeder Übersetzungseinheit vordefiniert:

Die folgenden zusätzlichen Makronamen können von einer Implementierung vordefiniert sein:

Die Werte dieser Makros (außer __FILE__ und __LINE__ ) bleiben während der gesamten Übersetzungseinheit konstant. Versuche, diese Makros neu zu definieren oder ihre Definition aufzuheben, führen zu undefiniertem Verhalten.

Beispiel

#include <stdio.h>
// make function factory and use it
#define FUNCTION(name, a) int fun_##name(int x) { return (a) * x; }
FUNCTION(quadruple, 4)
FUNCTION(double, 2)
#undef FUNCTION
#define FUNCTION 34
#define OUTPUT(a) puts( #a )
int main(void)
{
    printf("quadruple(13): %d\n", fun_quadruple(13));
    printf("double(21): %d\n", fun_double(21));
    printf("%d\n", FUNCTION);
    OUTPUT(billion); // note the lack of quotes
}

quadruple(13): 52
double(21): 42
34
billion

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C-Standards angewendet.

Referenzen

Siehe auch