Markro für speziellen Funktioncall

[clonephone82 (Gast)]

Hallo,

Wir haben sehr viele stellen in unserem Code wo immer wieder solch ein 
Konstrukt verwendet wird um eine Funktion aufzurufen.

if (err == ERR_OK)
{
   err = foo();
}

Ich wollte das jetzt mit einem Makro leserlicher machen.

#define CALL(func) \
  if (err == ERR_OK){ \
    err = func; \
  } \

Dann kann ich ja so den Aufruf machen.

CALL(foo());

Mein Kollege mag Makros nicht! Und findet diese gefährlich wie auch 
immer. Seht ihr hier irgendwelche Nachteile?

Funktional ist das doch das selbe - Auch die Codegröße ist die gleiche!

Vielen Dank.

[morgul (Gast)]

Außer dass ich mir einen anderen Namen als CALL aussuchen würde sollte 
das kein Problem sein. Ja, mit Makros kann man ziemlichen Mist bauen, 
muss man aber nicht...

[Oliver (Gast)]

Mach eine richtige Funktion daraus, kein Makro, und überlassl dem 
Compiler mögliches inlining.

Oliver

[Klaus W. (mfgkw)]

Zumindest würde ich auch den Namen deutlich aussagekräftiger machen.
Zudem arbeitet das Makro mit zwei Dingen:
- der Funktion
- der Fehlervariablen

Erstens wäre es flexibler, zweitens wesentlich prägnanter für den Leser, 
wenn man dies beides als Parameter übergibt.

Weiterhin sieht ein Makroaufruf aus wie eine ausführbare Anweisung.
Damit sie das auch weiterhin ist (ggf. mit überflüssigen Semikolon, 
später mal einem if davor und einem else dahinter oder anderen 
Spielereien), würde ich noch die do-while-Konstruktion rumbauen.

Deshalb würde ich vorschlagen:

#define CALL(function,error)      \
  do                              \
  {                               \
      if (error == ERR_OK)        \
      {                           \
          error = function();     \
      }                           \
  } while( 0 )

Konsequenterweise könnte man ERR_OK vielleicht auch noch als 
Makroparameter durchschieben, hängt davon ab...

Der gleichwertige Aufruf wäre dann:

CALL_FUN_IF_ERR_OK( foo, err );

Evtl. könnte man das alles aber auch weglassen.
Wenn es nämlich nur darum geht, mehrere Funktionsaufrufe zu machen, ohne 
mehrfach auf Fehler reagieren zu müssen, könnte man auch ganz ohne 
Makros so vorgehen:

    if( (err = f1()) != ERR_OK
        &&
        (err = f2()) != ERR_OK
        &&
        (err = f3()) != ERR_OK
        &&
        (err = f4()) != ERR_OK
        ...
      )
     ...

[Rolf Magnus (Gast)]

Oliver schrieb:
> Mach eine richtige Funktion daraus, kein Makro, und überlassl dem
> Compiler mögliches inlining.

Das ist aber nur praktikabel, wenn die aufzurufenden Funktionen alle 
keine Parameter (oder zumindest die gleiche Parameterliste haben), sonst 
muß man sich nachher womöglich Dutzende solcher Wrapper-Funktionen 
schreiben.

[Ralf G. (ralg)]

Oder wie wäre sowas? (ohne externes 'if'; Funktion wird immer aufgerufen 
und prüft selber)

int function(int error)
{
 if (error != ERR_OK)
  return error;
// ---
// eigentlicher Code
// ---
}

[clonephone82 (Gast)]

vielen dank für die Beiträge!
Wir haben uns jetzt auf die Variante von Klaus geeinigt.

Danke

[clonephone82 (Gast)]

Achso das mit dem do{ while(0) verstehe ich noch nicht ganz ich habs mit 
und ohne probiert funktioniert.
Was ist hier der Sinn?

[Klaus W. (mfgkw)]

Natürlich sehr lobenswert :-)

Wobei ich leider vergessen hatte, das Makro in der Definition von CALL 
auf CALL_FUN_IF_ERR_OK umzubenennen, aber das habt ihr wohl schon selber 
registriert.

[Klaus W. (mfgkw)]

clonephone82 schrieb:
> Achso das mit dem do{ while(0) verstehe ich noch nicht ganz ich habs mit
> und ohne probiert funktioniert.
> Was ist hier der Sinn?

Angenommen, du hast dein Original-Makro.
Dann schreibst du hin:

   if( blabla ) CALL( f() )
   else puts( "kein blabla.." );

Dann erwartest du, daß entweder das CALL gemacht wird, oder das puts().

Tatsächlich macht der Präprozessor daraus aber:

   if( blabla ) if (err == ERR_OK){
    err = f();
  }
   else puts( "kein blabla.." );

Wenn man das richtig einrückt, sieht es so aus:

   if( blabla )
     if (err == ERR_OK)
     {
        err = f();
     }
     else puts( "kein blabla.." );

D.h. das else gehört jetzt nicht mehr zum ersten if, zu dem du es haben 
möchtest, sondern zum if aus dem Makro.
Der Compiler übersetzt das, aber du weisst nicht warum das Programm 
Unfug macht.

Ähnliche Fälle lassen sich noch mehr konstruieren.

Mit dem do...while(0) wird aus allem innerhalb etwas in sich 
abgeschlossenes, was keine solchen Nebeneffekte mehr erzeugen sollte.

Sieht doof aus, hilft aber.

[Bronco (Gast)]

Das Problem kann man übrigens auch vermeiden, indem man immer 
geschweifte Klammern um die Blöcke schreibt, auch wenn sie nur eine 
Anweisung enthalten.

if( blabla ) 
  { CALL( f() ); }
else 
  { puts( "kein blabla.." ); }

Gefällt mir persönlich besser...

[Jörg W. (dl8dtl) (Moderator)]

Bronco schrieb:
> Gefällt mir persönlich besser...

Das Problem dabei ist, dass du auf die Disziplin des Makro-*Anwenders*
vertrauen musst, während das do...while(0) die Sache auf Ebene des
Makro-*Autors* löst (der ja schließlich den potenziellen Seiteneffekt
des Makros kennt).

[Klaus W. (mfgkw)]

Jörg Wunsch schrieb:
> während das do...while(0) die Sache auf Ebene des
> Makro-*Autors* löst

genau

Bronco schrieb:
> indem man immer
> geschweifte Klammern um die Blöcke schreibt, auch wenn sie nur eine
> Anweisung enthalten.
> ...
> Gefällt mir persönlich besser...

genau

-> es schadet ja nichts, beides zu machen

[Johann L. (gjlayde)]

Klaus Wachtler schrieb:
> Jörg Wunsch schrieb:
>> während das do...while(0) die Sache auf Ebene des
>> Makro-*Autors* löst
>
> genau
>
> Bronco schrieb:
>> indem man immer
>> geschweifte Klammern um die Blöcke schreibt, auch wenn sie nur eine
>> Anweisung enthalten.
>> ...
>> Gefällt mir persönlich besser...
>
> genau
>
> -> es schadet ja nichts, beides zu machen

Kann man aber nur dann, wenn man auch beide Rollen hat ;-)


Bitte reduzieren Sie die Anzahl der Zitatzeilen.
Bitte reduzieren Sie die Anzahl der Zitatzeilen.

[Klaus W. (mfgkw)]

Oder die andere Rolle dazu nötigen kann :-)

[Johann L. (gjlayde)]

Weitere Möglichkeit ist, CALL als variadisches Makro zu schreiben (C99) 
und einen bewerteten Block zu verwenden.

Damit lassen sich Aufrufe schachteln und ganz genauso wie normale 
C-Ausdrücke verwenden:
 

extern int fi (int);
extern int fc (char);
extern int fv (void);
extern int fp (const char*, ...);

#define CALL(F, ERR, ARGS...)   \
({                              \
    int _e = ERR;               \
    if (_e)                     \
        _e = F (ARGS);          \
    _e;                         \
})


int call (int i, char c, int error)
{
  error = CALL (fi, error, i);
  error = CALL (fc, error, c);
  error = CALL (fv, error);
  error = CALL (fi, CALL (fi, error, i), i);
    
  if (CALL (fp, error, "%s", i)
      || CALL (fp, error, "%c", c, i))
    return 0;

  return error;
}

 
Damit bleibt zumindest die Quelle leserlich und sieht genauso aus wie 
eine C-Quelle, zudem muß der Eingabeparameter ERR kein Lvalue sein.

Neben der Möglickkeit, ein allgemeines CALL-Makro zuverwenden kann man 
auch für jeden Callee ein eigenes Makro zur Verfügung stellen, daß den 
ersten Parameter wie ERR verwendet und die verbleibenden an den Callee 
reicht.

[clonephone82 (Gast)]

@alle vielen dank.