Makros C (#define Probleme)

[The_Rock (Gast)]

Hallo Leute,

ich habe mal eine Frage
was bewikt eigentlich diese #define anweisung ?:
#define Function_xy {}

wenn ich voher in meiner Routine eine Funktion mit gleicher Name, aber 
so difiniert habe:
int Function_xy(int a , int b)
{
  return irgenwas;
}

MfG

[Uhu U. (uhu)]

Das bewirkt, das der Preprozesseor aus einem Aufruf

   Function_xy(a, b);

folgenden Text macht:

   {}(a, b);

Welchen Sinn das ergibt, kannst du als Hausaufgabe selbst überlegen

[The_Rock (Gast)]

das ist NICHT das was ich meine!

die Funktion Function_xy(int a, int b) weiß schon was sie tue. nämlich 
meineswegens 2 Zahlen addieren und züruckgeben

angenommen irgewann in meiner Routine, daß ich so was schreibe:

#ifdef Aktiv
#define Function_xy {} //ist Function_xy {} == Function_xy(int a, int 
b)??
#endif

[Karl H. (kbuchegg)]

The_Rock wrote:
> Hallo Leute,
>
> ich habe mal eine Frage
> was bewikt eigentlich diese #define anweisung ?:
> #define Function_xy {}

Sie bewirkt das was jeder #define macht.
Sie sorgt dafür, dass ab der Stelle an der der #define vorkommt
bis zum Ende des Quelltextes, jeglicher Text 'Function_xy' mit
dem Text '{}' ersetzt wird.

Nicht mehr und nicht weniger.

>
> wenn ich voher in meiner Routine eine Funktion mit gleicher Name, aber

#define wirken ab ihrem Auftreten bis zum Ende des Quelltextes. Was
davor war interessiert den #define nicht.

Wenn dir das als Antwort nicht reicht, dann stell mal ein
möglichst komplettes Beispiel zusammen, welches so durch
den Compiler geht.

[Uhu U. (uhu)]

@The_Rock:

Dann verstehst du offenbar deine eigene Frage nicht... Dein letzter 
Beitrag ist jedenfalls völliger Unsinn.

Falls deine Frage ernst gemeint sein sollte:
Jeder C-Comiler hat einen Schalter, der ihn dazu veranlaßt, die Ausgabe 
des Preprocessors in eine Datei auszugeben. Mach das und sieh dir an, 
was der Compiler aus deinen Eingaben macht.

[DerSchelm (Gast)]

Wirf mal einen Blick ins LST-File, dort ist es aufgedröselt.

[Rolf Magnus (Gast)]

> das ist NICHT das was ich meine!

Es ist aber das, was der Compiler macht.

> die Funktion Function_xy(int a, int b) weiß schon was sie tue.

Das ist dem #define aber egal.

> #ifdef Aktiv
> #define Function_xy {} //ist Function_xy {} == Function_xy(int a, int
> b)??
> #endif

Nochmal: Der Präprozessor ist im Prinzip nur ein automatisierter 
Texteditor, der den Quelltext vor der Übergabe an den eigentlichen 
Compiler noch verändert. Ein

#define Function_xy {}

sorgt dafür, daß im Quelltext nach diesem #define jedes Vorkommen von 
"Function_xy" durch "{}" ersetzt wird, bevor es an den Compiler 
weitergeht. Es macht also aus einem

Function_xy(int a, int b)

ein

{}(int a, int b)

Wenn du die Funktion irgendwo aufrufst, z.B. mit

Function_xy(3, 5);

wird auch dieser Aufruf ersetzt durch:

{}(3, 5);