Warum scheinbar bedeutungslose do-while- und if-else-Anweisungen in Makros verwenden?

In vielen C / C ++ - Makros sehe ich den Code des Makros in einer scheinbar bedeutungslosen do whileSchleife. Hier sind Beispiele.

#define FOO(X) do { f(X); g(X); } while (0)
#define FOO(X) if (1) { f(X); g(X); } else

Ich kann nicht sehen, was der do whilemacht. Warum nicht einfach ohne schreiben?

#define FOO(X) f(X); g(X)

Die do ... whileund if ... elsesind dazu da, damit ein Semikolon nach Ihrem Makro immer dasselbe bedeutet. Angenommen, Sie hatten so etwas wie Ihr zweites Makro.

#define BAR(X) f(x); g(x)

Wenn Sie nun BAR(X);eine if ... elseAnweisung verwenden, bei der die Textkörper der if-Anweisung nicht in geschweifte Klammern gesetzt sind, erhalten Sie eine schlechte Überraschung.

if (corge)
  BAR(corge);
else
  gralt();

Der obige Code würde sich erweitern in

if (corge)
  f(corge); g(corge);
else
  gralt();

Das ist syntaktisch falsch, da das else nicht mehr mit dem if verknüpft ist. Es hilft nicht, Dinge innerhalb des Makros in geschweifte Klammern zu setzen, da ein Semikolon nach den Klammern syntaktisch falsch ist.

if (corge)
  {f(corge); g(corge);};
else
  gralt();

Es gibt zwei Möglichkeiten, das Problem zu beheben. Das erste ist, ein Komma zu verwenden, um Anweisungen innerhalb des Makros zu sequenzieren, ohne es seiner Fähigkeit zu berauben, sich wie ein Ausdruck zu verhalten.

#define BAR(X) f(X), g(X)

Die obige Version von bar BARerweitert den obigen Code in das Folgende, was syntaktisch korrekt ist.

if (corge)
  f(corge), g(corge);
else
  gralt();

Dies funktioniert nicht, wenn Sie stattdessen f(X)einen komplizierteren Code haben, der in einem eigenen Block abgelegt werden muss, beispielsweise um lokale Variablen zu deklarieren. Im allgemeinsten Fall besteht die Lösung darin, do ... whiledas Makro als einzelne Anweisung zu verwenden, die ohne Verwirrung ein Semikolon enthält.

#define BAR(X) do { \
  int i = f(X); \
  if (i > 4) g(i); \
} while (0)

Sie müssen nicht verwenden do ... while, Sie könnten auch etwas damit kochen if ... else, obwohl es, wenn es if ... elseinnerhalb eines erweitert wird if ... else, zu einem " baumelnden Anderen " führt, was es noch schwieriger machen könnte, ein bestehendes Problem des baumelnden Anderen zu finden, wie im folgenden Code .

if (corge)
  if (1) { f(corge); g(corge); } else;
else
  gralt();

Es geht darum, das Semikolon in Kontexten zu verwenden, in denen ein baumelndes Semikolon fehlerhaft ist. Natürlich könnte (und sollte) an dieser Stelle argumentiert werden, dass es besser wäre, BARals tatsächliche Funktion und nicht als Makro zu deklarieren .

Zusammenfassend lässt sich sagen, do ... whiledass dies dazu dient, die Mängel des C-Präprozessors zu umgehen. Wenn diese C-Styleguides Ihnen sagen, dass Sie den C-Präprozessor ausschalten sollen, ist dies die Art von Sache, über die sie sich Sorgen machen.

Makros sind kopierte / eingefügte Textteile, die der Vorprozessor in den Originalcode einfügt. Der Autor des Makros hofft, dass der Ersatz einen gültigen Code erzeugt.

Es gibt drei gute "Tipps", um dies zu erreichen:

Helfen Sie dem Makro, sich wie echter Code zu verhalten

Normaler Code wird normalerweise durch ein Semikolon beendet. Sollte der Benutzer den Ansichtscode nicht benötigen ...

doSomething(1) ;
DO_SOMETHING_ELSE(2)  // <== Hey? What's this?
doSomethingElseAgain(3) ;

Dies bedeutet, dass der Benutzer erwartet, dass der Compiler einen Fehler erzeugt, wenn das Semikolon fehlt.

Der wirklich gute Grund ist jedoch, dass der Autor des Makros das Makro möglicherweise irgendwann durch eine echte Funktion ersetzen muss (möglicherweise inline). Das Makro sollte sich also wirklich wie eines verhalten.

Wir sollten also ein Makro haben, das ein Semikolon benötigt.

Erstellen Sie einen gültigen Code

Wie in der Antwort von jfm3 gezeigt, enthält das Makro manchmal mehr als eine Anweisung. Und wenn das Makro in einer if-Anweisung verwendet wird, ist dies problematisch:

if(bIsOk)
   MY_MACRO(42) ;

Dieses Makro könnte erweitert werden als:

#define MY_MACRO(x) f(x) ; g(x)

if(bIsOk)
   f(42) ; g(42) ; // was MY_MACRO(42) ;

Die gFunktion wird unabhängig vom Wert von ausgeführt bIsOk.

Dies bedeutet, dass wir dem Makro einen Bereich hinzufügen müssen:

#define MY_MACRO(x) { f(x) ; g(x) ; }

if(bIsOk)
   { f(42) ; g(42) ; } ; // was MY_MACRO(42) ;

Erstellen Sie einen gültigen Code 2

Wenn das Makro so etwas wie:

#define MY_MACRO(x) int i = x + 1 ; f(i) ;

Wir könnten ein anderes Problem im folgenden Code haben:

void doSomething()
{
    int i = 25 ;
    MY_MACRO(32) ;
}

Weil es sich erweitern würde als:

void doSomething()
{
    int i = 25 ;
    int i = 32 + 1 ; f(i) ; ; // was MY_MACRO(32) ;
}

Dieser Code wird natürlich nicht kompiliert. Die Lösung verwendet also wieder einen Bereich:

#define MY_MACRO(x) { int i = x + 1 ; f(i) ; }

void doSomething()
{
    int i = 25 ;
    { int i = 32 + 1 ; f(i) ; } ; // was MY_MACRO(32) ;
}

Der Code verhält sich wieder korrekt.

Semikolon + Scope-Effekte kombinieren?

Es gibt ein C / C ++ - Idiom, das diesen Effekt erzeugt: Die do / while-Schleife:

do
{
    // code
}
while(false) ;

Das do / while kann einen Bereich erstellen, wodurch der Code des Makros gekapselt wird, und benötigt am Ende ein Semikolon, wodurch es zu Code erweitert wird, der einen benötigt.

Der Bonus?

Der C ++ - Compiler optimiert die do / while-Schleife, da die Tatsache, dass ihre Nachbedingung falsch ist, zur Kompilierungszeit bekannt ist. Dies bedeutet, dass ein Makro wie folgt:

#define MY_MACRO(x)                                  \
do                                                   \
{                                                    \
    const int i = x + 1 ;                            \
    f(i) ; g(i) ;                                    \
}                                                    \
while(false)

void doSomething(bool bIsOk)
{
   int i = 25 ;

   if(bIsOk)
      MY_MACRO(42) ;

   // Etc.
}

wird korrekt erweitert als

void doSomething(bool bIsOk)
{
   int i = 25 ;

   if(bIsOk)
      do
      {
         const int i = 42 + 1 ; // was MY_MACRO(42) ;
         f(i) ; g(i) ;
      }
      while(false) ;

   // Etc.
}

und wird dann als kompiliert und optimiert

void doSomething(bool bIsOk)
{
   int i = 25 ;

   if(bIsOk)
   {
      f(43) ; g(43) ;
   }

   // Etc.
}

@ jfm3 - Du hast eine schöne Antwort auf die Frage. Vielleicht möchten Sie auch hinzufügen, dass das Makro-Idiom auch das möglicherweise gefährlichere (weil es keinen Fehler gibt) unbeabsichtigte Verhalten mit einfachen 'if'-Anweisungen verhindert:

#define FOO(x)  f(x); g(x)

if (test) FOO( baz);

erweitert sich zu:

if (test) f(baz); g(baz);

Dies ist syntaktisch korrekt, sodass kein Compilerfehler vorliegt, hat jedoch die wahrscheinlich unbeabsichtigte Folge, dass g () immer aufgerufen wird.

Die obigen Antworten erklären die Bedeutung dieser Konstrukte, aber es gibt einen signifikanten Unterschied zwischen den beiden, der nicht erwähnt wurde. In der Tat gibt es einen Grund, das do ... whiledem if ... elseKonstrukt vorzuziehen .

Das Problem des if ... elseKonstrukts ist, dass Sie nicht gezwungen werden , das Semikolon einzufügen. Wie in diesem Code:

FOO(1)
printf("abc");

Obwohl wir das Semikolon (aus Versehen) weggelassen haben, wird der Code auf erweitert

if (1) { f(X); g(X); } else
printf("abc");

und wird stillschweigend kompiliert (obwohl einige Compiler möglicherweise eine Warnung für nicht erreichbaren Code ausgeben). Die printfAnweisung wird jedoch niemals ausgeführt.

do ... whileKonstrukt hat kein solches Problem, da das einzige gültige Token nach dem while(0)ein Semikolon ist.

Während erwartet wird, dass Compiler die do { ... } while(false);Schleifen optimieren , gibt es eine andere Lösung, die dieses Konstrukt nicht erfordern würde. Die Lösung besteht darin, den Komma-Operator zu verwenden:

#define FOO(X) (f(X),g(X))

oder noch exotischer:

#define FOO(X) g((f(X),(X)))

Dies funktioniert zwar gut mit separaten Anweisungen, funktioniert jedoch nicht in Fällen, in denen Variablen erstellt und als Teil von #define:

#define FOO(X) (int s=5,f((X)+s),g((X)+s))

Damit wäre man gezwungen, das do / while-Konstrukt zu verwenden.

Die P99-Präprozessorbibliothek von Jens Gustedt (ja, die Tatsache, dass so etwas existiert, hat mich auch umgehauen!) Verbessert das if(1) { ... } elseKonstrukt auf eine kleine, aber signifikante Weise, indem Folgendes definiert wird:

#define P99_NOP ((void)0)
#define P99_PREFER(...) if (1) { __VA_ARGS__ } else
#define P99_BLOCK(...) P99_PREFER(__VA_ARGS__) P99_NOP

Der Grund dafür ist, dass im Gegensatz zum do { ... } while(0)Konstrukt breakund continueinnerhalb des angegebenen Blocks immer noch gearbeitet wird, jedoch ((void)0)ein Syntaxfehler erstellt wird, wenn das Semikolon nach dem Makroaufruf weggelassen wird, wodurch der nächste Block sonst übersprungen würde. (Es gibt hier eigentlich kein "Dangling else" -Problem, da das elsean das nächste bindet if, das das im Makro ist.)

Wenn Sie an den Dingen interessiert sind, die mit dem C-Präprozessor mehr oder weniger sicher ausgeführt werden können, lesen Sie diese Bibliothek.

Aus bestimmten Gründen kann ich die erste Antwort nicht kommentieren ...

Einige von Ihnen zeigten Makros mit lokalen Variablen, aber niemand erwähnte, dass Sie nicht einfach einen Namen in einem Makro verwenden können! Es wird den Benutzer eines Tages beißen! Warum? Weil die Eingabeargumente in Ihre Makrovorlage eingesetzt werden. Und in Ihren Makrobeispielen verwenden Sie den wahrscheinlich am häufigsten verwendeten variablen Namen i .

Zum Beispiel beim folgenden Makro

#define FOO(X) do { int i; for (i = 0; i < (X); ++i) do_something(i); } while (0)

wird in der folgenden Funktion verwendet

void some_func(void) {
    int i;
    for (i = 0; i < 10; ++i)
        FOO(i);
}

Das Makro verwendet nicht die beabsichtigte Variable i, die am Anfang von some_func deklariert ist, sondern die lokale Variable, die in der do ... while-Schleife des Makros deklariert ist.

Verwenden Sie daher niemals gebräuchliche Variablennamen in einem Makro!

Erläuterung

do {} while (0)und if (1) {} elsesollen sicherstellen, dass das Makro auf nur 1 Befehl erweitert wird. Andernfalls:

if (something)
  FOO(X); 

würde erweitern zu:

if (something)
  f(X); g(X); 

Und g(X)würde außerhalb der ifSteueranweisung ausgeführt werden. Dies wird bei der Verwendung von do {} while (0)und vermieden if (1) {} else.

Bessere Alternative

Mit einem GNU- Anweisungsausdruck (der nicht Teil von Standard C ist) haben Sie eine bessere Möglichkeit als do {} while (0)und können dies if (1) {} elselösen, indem Sie einfach Folgendes verwenden ({}):

#define FOO(X) ({f(X); g(X);})

Und diese Syntax ist kompatibel mit Rückgabewerten (beachten Sie, dass dies do {} while (0)nicht der Fall ist), wie in:

return FOO("X");

Ich glaube nicht, dass es erwähnt wurde, also denken Sie darüber nach

while(i<100)
  FOO(i++);

würde übersetzt werden in

while(i<100)
  do { f(i++); g(i++); } while (0)

Beachten Sie, wie i++das Makro zweimal auswertet. Dies kann zu interessanten Fehlern führen.