#define in Header oder *.c-Datei?

[Michael S. (michl-s)]

Wenn ihr "#define"-Ausdrücke habt, die sich nur auf Funktion in einer
einzigen *.c-Datei beziehen, wo deklariert ihr diese dann? In der
*.c-Datei oder im zugehörigen Header, welcher auch von anderen Funktion
inkludiert wird?
Letzer Fall würde ja bedeuten, dass diese "defines" auch in den
inkludierenden Dateien bekannt wäre.
Und wie sieht das ganze mit (Datei-lokalen) Variablen und Structs aus?
Auch alle direkt in die *.c-Datei?

Danke.

Edit: Ich geb hier mal ein Beispiel:

Datei: hw_LCD.h

#ifndef __HW_LCD_H__
#define __HW_LCD_H__


/*****************************************/
/************** Definitions **************/
/*****************************************/
// Control Signal Data Pins
#define  LCD_RS    LATDbits.LATD8      // LCD RS signal
#define LCD_RW    LATDbits.LATD9      // LCD R/W signal
#define LCD_1_EN   LATDbits.LATD10    // LCD_1 E signal 
#define LCD_2_EN  LATDbits.LATD10   // LCD_1 E signal 
#define LCD_3_EN  LATDbits.LATD10      // LCD_1 E signal 

// LCD Addresses
#define  LCD_START_LINE1  0x00  
#define  LCD_START_LINE2  0x40
#define  LCD_START_LINE3  0x14
#define  LCD_START_LINE4  0x54

// Data Signals and Pin Direction
#define LCD_DATA       LATD               // Port for LCD data
#define LCD_IO_CNTRL  TRISD

// LCD Maximum Positions (beginning with 0)
#define LCD_MAX_Y    1
#define LCD_MAX_X    15

// Lines (beginning with 0)
#define LINE1  0
#define LINE2  1
#define LINE3  2
#define LINE4  3

// PutStr-Controls
#define  CONTINOUS    0
#define  LIMITED      1

// Structure LCD Line
typedef struct {
  unsigned char X;
  unsigned char Y;
}TYPE_LCD_CURSORS;

// Structure LC-Display
typedef struct {
  TYPE_LCD_CURSORS Cursor;
  unsigned int En  :1;
  unsigned int ID  :3;
  unsigned    :4;
}TYPE_LC_DISPLAY;



/*****************************************/
/*********** Global Variables ************/
/*****************************************/



/*****************************************/
/********** Function Prototypes **********/
/*****************************************/

// Macros
/*****  LCD COMMAND FUCNTION PROTOTYPES  *****/
#define __hw_LCD_Cursor_R(lcd)      hw_Cmd_LCD (0x0014, lcd)
#define __hw_LCD_Cursor_L(lcd)      hw_Cmd_LCD (0x0010, lcd)
#define __hw_LCD_Cursor_Invisible(lcd)  hw_Cmd_LCD (0x000C, lcd)
#define __hw_LCD_Cursor_Underline(lcd)  hw_Cmd_LCD (0x000E, lcd)
#define __hw_LCD_Display_Shift(lcd)    hw_Cmd_LCD (0x001C, lcd)
#define __hw_LCD_Display_Blank(lcd)    hw_Cmd_LCD (0x0008, lcd)
#define __hw_LCD_Home_Clr(lcd)      hw_Cmd_LCD (0x0001, lcd)
#define __hw_LCD_Home_It(lcd)      hw_Cmd_LCD (0x0002, lcd) 
#define __hw_LCD_Line_2(lcd)      hw_Cmd_LCD (0x00C0, lcd)
#define __hw_LCD_Scroll_R_All(lcd)     hw_Cmd_LCD (0x001E, lcd)
#define __hw_LCD_Scroll_L_All(lcd)     hw_Cmd_LCD (0x0018, lcd)
#define __hw_LCD_Blinking_Block(lcd)  hw_Cmd_LCD (0x000F, lcd)


// Functions
/******  LCD FUNCTION PROTOYPES ******/
void hw_Open_LCD         (TYPE_LC_DISPLAY *Lcd);                    // initialize display    
void hw_Cmd_LCD       (unsigned int Cmd, TYPE_LC_DISPLAY *Lcd);          // write command to lcd
void hw_Data_LCD      (unsigned int Data, TYPE_LC_DISPLAY *Lcd);        // write data to lcd
void hw_PutStr_LCD    (unsigned int Op_Mode, unsigned char *Data, unsigned int Chars_to_Put, TYPE_LC_DISPLAY *Lcd);
void hw_Enable_LCD    (TYPE_LC_DISPLAY *Lcd);
void hw_Disable_LCD      (TYPE_LC_DISPLAY *Lcd);
void hw_RegisterID_LCD   (TYPE_LC_DISPLAY *Lcd, unsigned int LCD_Nr);
void hw_Gotoxy_LCD     (unsigned char X, unsigned char Y, TYPE_LC_DISPLAY *Lcd);
void hw_Clear_LCD     (TYPE_LC_DISPLAY *Lcd);
int hw_ReadBusyFlag_LCD (TYPE_LC_DISPLAY *Lcd);


#endif //__HW_LCD_H__

Wäre das struct TYPE_LC_DISPLAY dann auch in allen anderen Dateien 
bekannt, die diese Datei inkludieren?
Eigentlich ja nicht, da hier nur die Typdefinition stattfindet, oder?

[Rufus Τ. F. (rufus)]

Michael S. schrieb:
> Wäre das struct TYPE_LC_DISPLAY dann auch in allen anderen Dateien
> bekannt, die diese Datei inkludieren?

Das ist ein typedef, also nur eine Typdefinitioni, und die ist dann 
überall dort bekannt, wo die Headerdatei eingebunden wird.

Und das muss auch so sein, denn sonst lassen sich die darauffolgenden 
Funktionsprototypen nicht verwenden.

[Karl H. (kbuchegg)]

Michael S. schrieb:
> Wenn ihr "#define"-Ausdrücke habt, die sich nur auf Funktion in einer
> einzigen *.c-Datei beziehen, wo deklariert ihr diese dann? In der
> *.c-Datei oder im zugehörigen Header, welcher auch von anderen Funktion
> inkludiert wird?

Die Grundregel sollte sein:
Immer im kleinsten Scope (Sichtbarkeitsbereich), der möglich ist. (Mit 
#define machen die meisten insofern eine Ausnahme, dass sie am Anfang 
der Datei zusammengezogen werden)

Wenn eine Struktur ausschliesslich nur in einer Funktion benötigt wird, 
dann kommt sie auch in diese Funktion.

Wenn alle Funktionen eines Moduls dieselbe Struktur benötigen UND alle 
Funktionen in einem *.c File zusammengezogen sind, dann kommt die 
Strukturdefinition an den Anfang dieses *.c Files.

Wenn das nicht geht, weil zb mehrere *.c Files diese Struktur benötigen, 
dann kommt sie in ein Header File.

Aber grundsätzlich möchte man haben, dass die Sichtbarkeit auf das 
allernotwendigste Minimum eingeschränkt wird. Dadurch kann man 
gewährleisten, dass es zu möglichst wenigen unbeabsichtigten 
Nebeneffekten kommt.

Wenn eine Struktur im externen Headerfile benötigt wird, aber nur in der 
Form, dass der Benutzer eines Moduls nur einen Pointer von einer 
Funktion bekommt und andere Funktionen wiederrum mit diesem Pointer 
füttern muss, dann kann man auch mittels einer Forward-Deklaration den 
Compiler insofern zufrieden stellen, dass zwar beim Modulverwender 
bekannt ist, dass es eine Struktur mit einem bestimmten Namen gibt, die 
Details des Strukturaufbaues allerdings nicht im Header File 
aufscheinen.