[C] Funktionen in Abhängigkeit von defines kompilieren

[B. S. (bestucki)]

Hallo zusammen,
Erstmal Code, die Problembeschreibung steht ganz unten.


Angenommen, ich habe folgendes Header-File foo.h:

#ifndef FOO_H_
#define FOO_H_

#include <stdint.h>

foo_a(uint8_t data);
foo_b(uint16_t data);
foo_c(uint32_t data);

#endif /* FOO_H_ */

#ifndef FOO_D_INCLUDED
  #ifdef FOO_D
    #define FOO_D_INCLUDED
    void foo_d(uint24_t data);
  #endif /* FOO_D */
#endif /* FOO_D_INCLUDED */
#undef FOO_D

#ifndef FOO_E_INCLUDED
  #ifdef FOO_E
    #define FOO_E_INCLUDED
    void foo_e(uint64_t data);
  #endif /* FOO_E */
#endif /* FOO_E_INCLUDED */
#undef FOO_E

Dies ist dann das dazugehörige Source-File foo.c:

#ifdef FOO_D_INCLUDED
void foo_d(uint24_t data){
.
.
.
}
#endif /* FOO_D_INCLUDED */

#ifdef FOO_E_INCLUDED
void foo_e(uint64_t data){
.
.
.
}
#endif /* FOO_E_INCLUDED */

In einer anderen Source steht dann folgendes:

#define FOO_E
#include <foo.h>

In irgendeiner anderen dann:

#define FOO_D
#define FOO_E
#include <foo.h>

Nun zu meiner Frage:
Werden die beiden Funktionen in jedem Fall eingefügt und somit 
kompiliert oder hängt dies vom Präprozessor ab? Ich könnte mir gut 
vorstellen, dass dies von der Abarbeitungsreienfolge der einzelnen Files 
abhängen könnte, welche Funktionen nun wirklich eingefügt werden. Oder 
wie handhabt dies der Präprozessor?

Gibt es eine andere sinnvolle (evt. bessere) Möglichkeit, Funktionen in 
Abhängigkeit von defines einzufügen? Hier geht es vor allem darum, dass 
nicht alle Compiler die Datentypen uint24_t und uint64_t kennen und ich 
Funktionen, die diese Datentypen benutzen, mit defines zum Projekt 
hinzufügen möchte, ohne dabei foo.h oder foo.c zu ändern.


Ich hoffe, ich konnte mein Problem einigermassen verständlich 
ausdrücken.
Vielen Dank für eure Hilfe!

[Malte S. (maltest)]

Die defines in foo.c greifen beim Compilieren von foo.c. Ob in foo.h 
jetzt beim Compilieren von bar.c foo_d sichtbar ist oder nichts mag sich 
auf bar.c auswirken, aber niemals auf das aus foo.c entstandene 
Objektfile. Wenn du verschiedene Varianten von foo.o brauchst, musst du 
foo.c entsprechend mit verschiedenen defines compilieren und z.B. die 
Objetcs verschieden benennen oder platzieren.
Aber: wenn das vom Compiler abhängig ist, nimm doch an allen Stellen die 
üblichen defines zur Erkennung eines Compilers. Beim Wechsel der 
Toolchain musst du eh im Zweifelsfall alles neu compilieren.

[B. S. (bestucki)]

Vielen Dank für deine Antwort. Da hab ich wohl zu wenig weit gedacht...

Dank deines Vorschlags die Erkennung des Compilers zu verwenden, hatte 
ich gleich eine andere Idee: Da ich stdint.h verwende, müssen die 
Grenzen der Datentypen definiert worden sein. Dahr kann ich auf 
UINT8_MAX etc. testen. Somit muss ich auch nicht die Files ändern, wenn 
die Funktionen in einem anderen Projekt mit einem anderen Compiler 
verwendet werden.

Vielen Dank für den Denkanstoss!

[Rufus Τ. F. (rufus)]

be stucki schrieb:
> Dahr kann ich auf
> UINT8_MAX etc. testen.

Dieser Wert dürfte bei allen Compilern gleich sein.

[B. S. (bestucki)]

Rufus Τ. Firefly schrieb:
> Dieser Wert dürfte bei allen Compilern gleich sein.

Sorry, hab mich wohl zu wenig genau ausgedrückt. Ich prüfe nur mit

#ifdef UINT24_MAX
  void foo_d(uint24_t data);
#endif /* UINT24_MAX */

auf das Vorhandensein der Definition. Bei Compilern, die keine 24 oder 
64 Bit Integer verwenden, wird wohl UINT24_MAX und UINT64_MAX nicht 
definiert worden sein. Hoffe ich zumindest...