C: auf globale Variable zugreifen

[Frank (Gast)]

Hallo zusammen!

Ich habe hier grad ein Problem.

Ich habe eine Funktion in einer ausgelagerten .c-Datei. Die .h ist 
eingebunden. In dieser ausgelagerten .c-Datei möchte ich auf eine 
globale Variable in der main.c zugreifen, aber das klappt bis dato 
nicht. Was muss ich machen?

Irgendwo muss sicher ein extern oder ähnliches hin. Oder welche 
Möglichkeit gibt es noch?

[Hannes H. (mui)]

main:

int i=0;

andere c-datei:

extern int i;

so müsste das gehen

[Frank (Gast)]

Nee, tuts nicht, oder ich machs falsch.

[Mani (Gast)]

Funktioniert es nicht oder gibt es eine Fehlermeldung?
Wenn Fehlermeldung, was für eine?

Grüße

[Hannes H. (mui)]

Woran merkst du denn, dass es nicht funktioniert? Compilerfehler? 
Funktionale Fehler?
Wo ist dein Quellcode? Bißchen mehr Input wäre hilfreich.

[Frank (Gast)]

OK, sorry:

main.c

...
#include andere_datei.h

struct control
{
  uint16_t          menu_item;
  uint16_t          second_item;
  uint16_t          old_menu_item;
  uint8_t           item_init;
  uint8_t           i_prog;
  uint8_t           display_toggle;

volatile struct control RUNTIME_CONTROL = { 0, 0, 0, FALSE, FALSE, FALSE };

...

void main( void )
{
   ...
}

andere_datei.c

void funktion_a( void )
{
  ...
}

void funktion_b( void )
{
  extern struct RUNTIME_CONTROL;

  if( RUNTIME_CONTROL.display_toggle )
  {
    ...
  }
}

andere_datei.h

#ifndef ANDERE_DATEI_H
#define ANDERE_DATEI_H

void funktion_a( void );
void funktion_b( void );

#endif

Fehler: "A storage class may not be specified here"
Und:    "Identifier "RUNTIME_CONTROL" is undefined

[Hannes H. (mui)]

wenn du in der main

volatile struct control RUNTIME_CONTROL = { 0, 0, 0, FALSE, FALSE, FALSE };

anlegst, musst du in andere_datei.c auch auf VOLATILE struct control 
zugreifen:

void funktion_b( void )
{
  extern volatile struct RUNTIME_CONTROL;

  if( RUNTIME_CONTROL.display_toggle )
  {
    ...
  }

[Frank (Gast)]

Nee, hab ich auch gedacht, aber das gibt noch ne Warnung mehr:

Warning[Pe021]: type qualifiers are meaningless in this declaration

[Frank (Gast)]

OK, also generell geht es so. Es muss an dem struct liegen. Nehme ich 
einen einfachen int, dann is alles OK.

[Namehiereingeben (Gast)]

Wenn der Compiler nicht weiss wie die struct aufgebaut ist kann er auch 
keine Zugriffe auf Elemente davon übersetzen. Den Aufbau der struct hast 
du aber nur in der main.c dem Compiler beschrieben und nicht in der 
andere_datei.c.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Geht das: eine globale Variable lokal zu deklarieren?
Ich hätte gedacht, das muß so aussehen:

extern volatile struct RUNTIME_CONTROL;

void funktion_b( void )
{
   if( RUNTIME_CONTROL.display_toggle )

[Frank (Gast)]

Lothar Miller schrieb:
> eine globale Variable lokal zu deklarieren?

Global in der main, nicht in meiner Zusatzfunktion.

[Frank (Gast)]

OK, die Antwort kann man jetzt auch falsch verstehen...

[Frank (Gast)]

Namehiereingeben schrieb:
> Wenn der Compiler nicht weiss wie die struct aufgebaut ist kann er auch
> keine Zugriffe auf Elemente davon übersetzen. Den Aufbau der struct hast
> du aber nur in der main.c dem Compiler beschrieben und nicht in der
> andere_datei.c.

Also was muss ich noch machen?

[Sepp (Gast)]

main.h:

struct control
{
  uint16_t          menu_item;
  uint16_t          second_item;
  uint16_t          old_menu_item;
  uint8_t           item_init;
  uint8_t           i_prog;
  uint8_t           display_toggle;

volatile struct control RUNTIME_CONTROL;

in Andere Datei (und in main) dann main.h einbinden. Das mit extern war 
schon richtig

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Frank schrieb:
> Global in der main, nicht in meiner Zusatzfunktion.
Ich hatte da Probleme beim Verständnis der Sichtbarkeit der Variablen... 
;-)

Es reicht aus, wenn diese Deklaration hier

struct control
{
  uint16_t          menu_item;
  uint16_t          second_item;
  :
};

in den andere_datei.h Header kommt, damit der Inhalt des Structs in der 
Funktion bekannt ist.

[Knut (Gast)]

struct control
{
  uint16_t          menu_item;
  uint16_t          second_item;
  uint16_t          old_menu_item;
  uint8_t           item_init;
  uint8_t           i_prog;
  uint8_t           display_toggle;
}

das packste in die main.h

volatile struct control RUNTIME_CONTROL = { 0, 0, 0, FALSE, FALSE, FALSE };

das in die main.c

extern volatile struct control RUNTIME_CONTROL

das in die main.h

und dannincludest du die main.h in deine wasauchimmer.h


Knut

[Knut (Gast)]

Man seit ihr schnell heute....

[Knut (Gast)]

Sorry, du includest die main.h in deine wasauchimmer.*c*

Knut

[Frank (Gast)]

Lothar Miller schrieb:
> in den andere_datei.h Header kommt, damit der Inhant des Structs in der
> Funktion bekannt ist.

OK, ich habe jetzt gerade folgendes gemacht:

main.c

...
#include andere_datei.h

struct control
{
  uint16_t          menu_item;
  uint16_t          second_item;
  uint16_t          old_menu_item;
  uint8_t           item_init;
  uint8_t           i_prog;
  uint8_t           display_toggle;

volatile struct control RUNTIME_CONTROL = { 0, 0, 0, FALSE, FALSE, FALSE };

...

void main( void )
{
   ...
}

andere_datei.c

struct control
{
  uint16_t          menu_item;
  uint16_t          second_item;
  uint16_t          old_menu_item;
  uint8_t           item_init;
  uint8_t           i_prog;
  uint8_t           display_toggle;
};

extern volatile struct control RUNTIME_CONTROL;

void funktion_a( void )
{
  ...
}

void funktion_b( void )
{
  extern struct RUNTIME_CONTROL;

  if( RUNTIME_CONTROL.display_toggle )
  {
    ...
  }
}

andere_datei.h

#ifndef ANDERE_DATEI_H
#define ANDERE_DATEI_H

void funktion_a( void );
void funktion_b( void );

#endif

Ich habe das struct also nochmal in die andere .c-Datei gepackt - 
scheint auch erstmal zu gehen? Wo ist jetzt der Unterschied es in die 
.h- oder .c-Datei zu packen?

[Frank (Gast)]

Knut schrieb:
> das packste in die main.h

Sorry, aber was denn für eine main.H ? Hab ich nicht ;-)

[Knut (Gast)]

Dann mach dir eine...

Wenn du den Prototypen in der main.h machen würdest, dass eigentlich 
Struct in der main.c dann deklarierst, kannst du in anderen Files auf 
das Struct zugreifen, wenn du dort die main.h includierst. Vorher musst 
du natürlich noch in der main.h dein in der main.c deklariertes Struct 
als extern deklarieren.

Dann klappts auch mit den Nachbarfiles...


Knut

[Frank (Gast)]

OK, kann mir denn noch einer sagen, wo der Unterschied ist, ob ich

// andere_funktion.h

struct control
{
  uint16_t          menu_item;
  uint16_t          second_item;
  uint16_t          old_menu_item;
  uint8_t           item_init;
  uint8_t           i_prog;
  uint8_t           display_toggle;
};

extern volatile struct control RUNTIME_CONTROL;

oder

// andere_funktion.c

struct control
{
  uint16_t          menu_item;
  uint16_t          second_item;
  uint16_t          old_menu_item;
  uint8_t           item_init;
  uint8_t           i_prog;
  uint8_t           display_toggle;
};

extern volatile struct control RUNTIME_CONTROL;

mache?

[Detlev T. (detlevt)]

Ist das nicht nur ein Syntax-Fehler, weil das struct control einfach nie 
geschlossen wird (Klammer fehlt)?

[Frank (Gast)]

Detlev T. schrieb:
> Ist das nicht nur ein Syntax-Fehler, weil das struct control einfach nie
> geschlossen wird (Klammer fehlt)?

Nee, das war ein Kopierfehler ;-)

[Frank (Gast)]

Hab ich es denn jetzt richtig, oder klappt es grad nur aus gut Glück?

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

> OK, kann mir denn noch einer sagen, wo der Unterschied ist, ob ich
> // andere_funktion.h ...
> oder
> // andere_funktion.c ...
> mache?
Vermutlich steht in andere_datei.c auch das hier:
#include andere_datei.h

Und damit wäre der Struct sowohl in main.c wie auch in andere_date.c 
bekannt. Überall eben, wo er verwendet wird. Und darauf kommt es an.

[Karl H. (kbuchegg)]

Frank schrieb:
> OK, kann mir denn noch einer sagen, wo der Unterschied ist, ob ich

Stell dir einfach mal vor du machst das hier

main.c

struct control
{
  uint8_t   abc;
  uint16t   def;
};

struct control globvar;

int main()
{
  globvar.abc = 8;
  globvar.def = 16;

  foo();
}

andere.c

struct control
{
  double    abc;
  uint16t   def;
};

extern struct control globvar;

void foo()
{
  globvar.abc = 42.0
}

Grundsätzlich ist das von der Vorgehensweise her richtig. Jedes C-File 
ist in sich vollständig und hat alles was es braucht.
Aber: Die Strukturdefinitionen in den beiden C-Files stimmen NICHT 
überein. Das kann zb passieren, wenn man eine Strukturdefinition im 
Nachhinein noch erweitert oder umbaut.

Der Compiler kann dich davor nicht schützen! Der sieht sich immer nur 1 
C-File an. Was im anderen drinnen ist, interessiert ihn nicht.

Das wäre aber ein schwerer Fehler, wenn die Strukturaufbauten nicht 
übereinstimmen!

So rum

irgendwas.h

struct control
{
  double    abc;
  uint16t   def;
};

extern struct control globvar;

main.c

#include "irgendwas.h"

struct control globvar;

int main()
{
  globvar.abc = 8;
  globvar.def = 16;

  foo();
}

andere.c

#include "irgendwas.h"

void foo()
{
  globvar.abc = 42.0
}

kann dir dieser Fehler aber nicht passieren.
Dadurch, dass die eigentliche Strukturdefinition nur an EINER Stelle 
steht und überall wo sie gebraucht wird inkludiert wird, vermeidest du 
ganz einfach diesen Fehler.
Hier ist das verschieben in ein Header File also Selbstschutz um dich 
selbst vor Fehlern zu schützen.

[Namhiereingeben (Gast)]

Frank schrieb:
> OK, kann mir denn noch einer sagen, wo der Unterschied ist, ob ich// 
andere_funktion.h
(...)
> oder// andere_funktion.c
(...)
> mache?

Sofern du die andere_funktion.h in die andere_funktion.c mittels 
#include eingebunden hast ist da zunächst kein Unterschied - die 
#include-Anweisung sorgt im Compiler lediglich dafür, dass der Inhalt 
der angegebenen Datei an der Stelle des #include 1:1 eingelesen wird als 
ob man ihn direkt hingeschrieben hätte. Die struct in der .h zu 
definieren hat allerdings den Vorteil, dass man die .h-Datei noch in 
andere Dateien includen kann (z.B. in der main.c) und dort dann 
ebenfalls eine Definition dieser struct hat, ohne den Text der die 
struct beschreibt selbst in mehrere Dateien reinschreiben zu müssen.

Neben einem Hauch von Arbeitserleichterung verringert das auch die 
Wahrscheinlichkeit eines Fehlers: Da nur an einer Stelle Änderungen 
vorgenommen werden müssen um automatisch alle Verwendungen zu ändern 
besteht nicht das Risiko, dass man die Änderung in irgendeiner .c-Datei 
vergisst.