Wie schreibe ich ein einfaches Makro in C?

1

 #define MAKRONAME DEFINITION

C-Buch lesen...

Wobei Assembler Makros in C oft besser durch eine Funktion realisiert 
werden.

Ah natürlich ja...Bücher vorn Kopf klatsch
Hätte ich eines hier hätte ich auch nachgeschlagen -.- Solche Kommentare 
kann man sich doch schenken. Aber das hat ja auch was, indem man 
"Neulingen" einfach direkt einen vor den Bug ballert und ihnen die 
Motivation mit solch schlauen Sprüchen raubt...

Zum Thema:

Die Idee von Martin werde ich ausprobieren. Danke dafür.

Martins Lösung ist meiner Meinung nach nicht ganz vollständig (siehe 
Parameterliste des Makros). ;-)

Definition des Makros:

#define warte(i)\
{               \
 while(i++);    \
}

Anwendung des Makros:

warte(1000);


Tschau Sven!

...und es ist meist sinnvoll, Makronamen in GROSSBUCHSTABEN zu 
schreiben, um sie von Funktionen/Variablen unterscheiden zu können.

> Die Idee von Martin werde ich ausprobieren. Danke dafür.

Es macht mehr Sinn sich an den Vorschlag von Karl heinz Buchegger zu 
halten.

Sinn und Zweck eines Makros ist es doch, das der gleiche Code an 
verschiedenen Stellen ausgeführt wird. Das erreichst Du am elegantesten, 
durch eine Funktion.

Also z.B.

1

void warte(){

2

  while(i < j){

3

      ......

4

  }

5

}

DEFINES werden eher dafür benutzt um Compilerabhängige Codeanpassungen 
vorzunehmen.

Such einfach mal nach C Tutorial und lies doch ein paar Seiten.

Dieter Engelhardt wrote:
> Sinn und Zweck eines Makros ist es doch, das der gleiche Code an
> verschiedenen Stellen ausgeführt wird. Das erreichst Du am elegantesten,
> durch eine Funktion.
Die hat aber, im Gegensatz zu einem "echten" Makro (das nur eine 
Textersetzung vornimmt) einen oft nicht erwünschten Overhead. In dem 
Fall sollte man die fragliche Funktion eventuell inline deklarieren...

Sven P. wrote:
> Und nen aktuellen GCC dazu benutzen...
Na, das doch sowieso...

@ Dieter Engelhardt:

Hallo Dieter!

Es tut mir leid, aber da kann ich Dir so nicht zustimmen.

1) Mit Funktionen erreichst Du, daß ein und der selbe Code von 
unterschiedlichen Stellen des Programms aus zur Laufzeit angesprungen 
und ausgeführt werden kann.

2) Definierst Du ein Makro und benutzt es an mehren Stellen, wird immer 
wieder der selbe Code beim Übersetzen des Quellcodes in das Programm 
eingefügt (an jeder Stelle, an der das Makro benutzt wurde). Aus diesem 
Grund sollte man auch mit Makros vorsichtig sein, um das Programm nicht 
aufzublähen. Aufgrund der fehlenden Sprünge läuft es aber schneller. Die 
Verwendung von Makros lohnt sich bei kurzen Befehlssequenzen.

@Karl heinz Buchegger:

>Wobei Assembler Makros in C oft besser durch eine Funktion realisiert
>werden.

Was meinst Du damit genau? In Martins Beispiel handelt es sich doch um 
ein C-Makro.

Tschau Sven!

@Johannes M.

Mit inline definierte Funktionen als Alternative hast du natürlich 
recht.

Gibt es zwischen inline definierten Funktionen und Makros irgendwelche 
wichtigen Unterschiede bei der Abarbeitung?

Sven Woehlbier wrote:
> #define warte(i)\
> {               \
>  while(i++);    \
> }
>
> Anwendung des Makros:
> warte(1000);
Tolles Makro  :-o
Frage: Wie lange zählt das denn hoch?
Antwort: bis zum Überlauf der übergebenen Zahl.

Überhaupt bin ich mir nicht ganz sicher, dass genau dieser Aufruf 
funktionieren wird. Denn was macht der Preprozessor daraus?
>  { while(1000++); }
Macht das Sinn?

Sven Woehlbier wrote:

>>Wobei Assembler Makros in C oft besser durch eine Funktion realisiert
>>werden.
>
> Was meinst Du damit genau? In Martins Beispiel handelt es sich doch um
> ein C-Makro.

Es gibt genügend Fallstricke bei C-Makros.
Legionen von Programmieren sind darauf hereingefallen und werden es auch 
weiter tun.
Solange man weiß was man tut, können Makros nützlich sein. Hab selbst 
schon jede Menge Unfug mit Makros angestellt.
Aber irgendwann kommt man zur Erkenntnis, das man abwägen soll und muss, 
ob man eine bestimmte Funktionalität mit Makros oder mit einer Funktion 
realsiert. Makros als Funktionsersatz für generische Funktionen sollte 
gesetzlich verboten werden.

1

#define max(a,b)  ( (a) > (b) ? (a) : (b) )

und dann viel Spass beim Suchen warum zwar

1

     i = max( a, b );

funktioniert, sich aber

1

     j = max( i++, b );

"seltsam" verhält (nur um mal eines der prominentesten Beispiele zu 
benutzen. Die Liste ist beliebig verlängerbar).
Oder warum in

1

     k = max( NrOfEntries(), 100 );

die Funktion NrOfEntries manchmal, aber nicht immer, 2 mal aufgerufen 
wird. Wobei das bei einer Abzählfunktion ja noch relativ glimpflich ist, 
wenn aber von einem Konto ein bestimmter Betrag manchmal 2 mal abgebucht 
wird, dann erklär das mal deinem Kunden. Und vor allen Dingen find 
diesen Bug mal in einem Programm. Die Fehlermeldung deines Kunden 
lautet: Manchmal wird eine Abbuchung doppelt gemacht. Und dann stell da 
mal die Beziehung dazu her, dass du den Abbuchbetrag gegen einen 
Maximalbetrag getestet hast und das das die Ursache für die 2-te 
Abbuchung war.

Lothar Miller wrote:

> Überhaupt bin ich mir nicht ganz sicher, dass genau dieser Aufruf
> funktionieren wird. Denn was macht der Preprozessor daraus?
>>  { while(1000++); }
> Macht das Sinn?

Ich bin auch neugierig welche und wie verständlich die Fehlermeldungen 
des Compilers sind, sollte jemand mal auf die Idee kommen

1

  warte( GetWaitingTime() );

zu schreiben :-)

Kevin J. wrote:
> Ah natürlich ja...Bücher *vorn Kopf klatsch*
> Hätte ich eines hier hätte ich auch nachgeschlagen -.- Solche Kommentare
> kann man sich doch schenken. Aber das hat ja auch was, indem man
> "Neulingen" einfach direkt einen vor den Bug ballert und ihnen die
> Motivation mit solch schlauen Sprüchen raubt...

Wenn ich dir so zuhöre wundert es mich direkt wie Millionen von 
Programmierern vor der "Erfindung" des Internet überhaupt Programmieren 
erlernen konnten. Man war das damals demotivierend die IBM JCL Manuals 
tage-, ja wochenlang zu studieren.

@ Lothar Miller:

Kritik angekommen! Habe leider das Beispiel von Martin zu kritiklos 
übernommen. Hier jetzt aber ein lauffähiges Makro.


#define DELAY(pause){\
  clock_t start = clock();\
  while( (((clock()-start)*1000)/CLK_TCK) < pause );\
}

Sven Woehlbier wrote:
> @ Lothar Miller:
>
> Kritik angekommen! Habe leider das Beispiel von Martin zu kritiklos
> übernommen. Hier jetzt aber ein lauffähiges Makro.
>
>
> #define DELAY(pause){\
>   clock_t start = clock();\
>   while( (((clock()-start)*1000)/CLK_TCK) < pause );\
> }


Das kann (muss nicht) wiederrum für denjenigen, der dieses Makro 
benutzt zu seltsamen Effekten führen. Überleg dir einfach bei jedem(!) 
Makro das du schreibst, was wohl passieren wird, wenn du als Argument 
eine Variable++ einsetzt bzw. das Ergebnis eines Funktionsaufrufs 
benutzt.

1

  int Wartezeit = 0;

2

3

  while( Wartezeit < 100 ) {

4

    ToggleLed();

5

    DELAY( Wartezeit++ );

6

  }

verhält sich völlig anders, als man intuitiv beim Studim dieser 
Codezeilen erwarten würde. Um Ordnung in dieses Chaos zu bekommen, muss 
man die Internals von DELAY kennen, etwas was ich bei einer 
gleichnamigen Funktion delay() nicht muss. Immerhin warst du freundlich 
genug und hast den Makro Namen gross geschrieben, so dass jemand, der 
dieses Makro verwendet gewarnt ist und das Makro studiert ehe er es 
benutzt. Aber Hand aufs Herz: Willst du jedesmal, wenn du vorgefertigte 
Funktionalität benutzt erst überlegen müssen, wie das Makro wohl 
expandiert und ob es da mglw. zu Semantischen Fehlern kommen kann?

@Karl heinz Buchegger

Hallo Karl-Heinz!

Vielen Dank, für Deine Hinweise! Ich mußte erst auf Lothar reagieren, 
und wenigstens ein korrektes Makro präsentieren.

Auf die Idee das Makro mit Funktionsaufrufen und Variablen 
auszuprobieren, bin ich ehrlich gesagt noch nicht gekommen. Ich habe es 
ausschließlich mit einer Konstanten im Aufruf benutzt.

z.B. DELAY(1000);

Hintergrund bei der Sache ist, der Borland-Compiler, den ich hier 
benutze, unterstützt das alte delay() nicht mehr. Manchmal ist man eben 
nicht ganz frei in der Auswahl der Werkzeuge. Insgesamt hast Du aber 
recht, für einen anderen Programmierer könnte die Verwendung des Makros 
problematisch sein.

Ich glaube, wenn es dann etwas makro-ähnliches sein muß, sind mir die 
Inline Funktionen dann doch lieber.

Vielen Dank!
Tschau Sven!

Sven Woehlbier wrote:

> Ich glaube, wenn es dann etwas makro-ähnliches sein muß, sind mir die
> Inline Funktionen dann doch lieber.

Du bist am richtigen Weg!

genauso effizient wie Makros, nur dass sich der Compiler um diese ganzen 
kleinen Fallen kümmert :-)

Urs wrote:

> Da Macros ja nur Textersetzungen sind, macht der Compiler keine
> Typumwandlungen. Bei Funktionen aber schon. Auch wenn man sie nicht
> braucht.

Das ist natürlich ein Argument. Stimme ich zu.

> Und das oben angegebene max() Macro kann man z.B. für jeden möglichen
> Datentyp, also ints, longs, shorts, quads, floats, doubles, singed oder
> unsigned, pointer (macht keinen Sinn, geht aber), usw. benutzen. Sogar
> Kombinationen sind möglich.

Yep. Und allen gemeinsam sind die Fallen die man damit stellt :-)
Man muss also immer abwägen was einem wichtiger ist: "code and forget" 
bei möglicherweise etwas verminderter Laufzeit (um die Aussage von oben 
'genauso effizient' etwas zu entschärfen) oder "code and remember what 
pitfalls are waiting" aber dafür am schnellsten.

> Davon mal abgesehen sind viele Dinge mit inlined functions schlichtweg
> unmöglich.

Yep. Alles was mit Token-pasting und concatination zu tun hat.

> Sogar mit C++ Templates. Wer Macros links liegen lässt, weil
> sie ihm zu gefährlich sind, der wird m.E. niemals effizient C/C++
> programmieren lernen. Warum sind wohl die System headers alle voll mit
> Macros?

Weil die Header uralt sind und sich noch niemand die Mühe gemacht hat 
sie auf inline umzuschreiben.
Behaupte ich jetzt mal.