Code in Funktion zusammenfassen

[Sven (Gast)]

Hallo,

ich habe in meiner main Funktion mehrere Ereignis, die mehere lokale 
Variablen der Funktion main zurücksetzen sollen.

Bsp.

int main(void){
uint8_t Ereignis1
uint8_t Ereignis2
uint8_t Ereignis3
uint8_t Variable1
uint8_t Variable2
uint8_t Variable3
uint8_t Variable4
uint8_t Variable5

  while(1){
    if (Ereignis1){
      Variable1=0;
      Variable2=0;
      Variable3=0;
      Variable4=0;
      Variable5=0;
    }

    if (Ereignis2){
      Variable1=0;
      Variable2=0;
      Variable3=0;
      Variable4=0;
      Variable5=0;
    }

    if (Ereignis3){
      Variable1=0;
      Variable2=0;
      Variable3=0;
      Variable4=0;
      Variable5=0;
    }
  }
}

Nun hätte ich aber gerne eine Funktion geschrieben, die einfach 
aufgerufen wird und alle 5 Variablen zurückgesetzt werden (aufgrund 
Übersichtlichkeit und Schreibarbeit).
Die Funktion sähe dann z.B. so aus:

void Ruecksetzen (void){
  Variable1=0;
  Variable2=0;
  Variable3=0;
  Variable4=0;
  Variable5=0;
  
  return;
}

Nun ist ja aber das Problem, dass die Funktion die Variablen aus main 
nicht kennt.
Wir kann man so etwas lösen ohne die Variablen global anzulegen? Geht 
das überhaupt?

[egal (Gast)]

Was du brauchst sind Pointer.

[Jörg E. (jackfritt)]

Google 
http://abraham.informatik.fh-lausitz.de/profs/robel/faq/callByReference.html

[Peter D. (peda)]

Eine allgemeine Lösung gibt es nicht.
Wenn die Variablen irgendwas miteinander zu tun haben, legt man sie 
besser als Array oder Struct an. Zum Löschen kann man dann memset() 
benutzen.

memset( my_array, 0, sizeof(my_array));

Gegen global spricht eigentlich nichts, es sein denn, sie solllen 
schnell sein (in Registern).

Man kann auch den Code so umstellen, daß die gleiche Sache nur an einer 
Stelle auftritt:

int main(void){
uint8_t Ereignis1
uint8_t Ereignis2
uint8_t Ereignis3
uint8_t Variable1
uint8_t Variable2
uint8_t Variable3
uint8_t Variable4
uint8_t Variable5

  while(1){
    Variable1=0;
    Variable2=0;
    Variable3=0;
    Variable4=0;
    Variable5=0;
    while(1){
     if (Ereignis1)
       break;
     if (Ereignis2)
       break;
     if (Ereignis3)
       break;
     if (Ereignis4)
       break;
    }
  }
}

Peter

[Karl H. (kbuchegg)]

Sven schrieb:

> Wir kann man so etwas lösen ohne die Variablen global anzulegen? Geht
> das überhaupt?


Du brauchst sehr dringend ein C-Buch.
Argument Passing an Funktionen und alles was damit zusammenhängt ist 
eine grundlegende Basistechnik in der Programmierung.

void foo( int* i)
{
  *i = 5;
}

int main()
{
  int j = 8;

  // j hat den Wert 8

  foo( &j );

  // jetzt hat j den Wert 5. foo hat ihn gesetzt
}

[Peter II (Gast)]

Karl Heinz Buchegger schrieb:
> Argument Passing an Funktionen ist eine grundlegende Basistechnik.

das ist zwar richtig, aber für 5 Variablen würde ich das nicht als 
sinnvoll ansehen. Hier ist wirklich die einfachste Lösung die Variablen 
global zu machen.

[Karl H. (kbuchegg)]

Peter II schrieb:
> Karl Heinz Buchegger schrieb:
>> Argument Passing an Funktionen ist eine grundlegende Basistechnik.
>
> das ist zwar richtig, aber für 5 Variablen würde ich das nicht als
> sinnvoll ansehen.

Nächste Basistechnik:
Die Variablen haben ja meistens einen sinnvollen Bezug zueinander. Da 
stülpt man dann eine struct drüber.

[Fabian O. (xfr)]

Variablen, die man dauerhaft braucht, lokal in der main-Funktion 
anzulegen macht ohnehin nicht viel Sinn. Damit verschleiert man nur den 
Speicherverbrauch und erschwert sich, wie man sieht, das Programmieren.

Mach die Variablen modul-global, wenn mehrere Funktionen darauf 
zugreifen sollen:

static uint8_t Ereignis1;
static uint8_t Ereignis2;
static uint8_t Ereignis3;
static uint8_t Variable1;
static uint8_t Variable2;
static uint8_t Variable3;
static uint8_t Variable4;
static uint8_t Variable5;

static void reset_vars(void)
{
  Variable1 = 0;
  Variable2 = 0;
  Variable3 = 0;
  Variable4 = 0;
  Variable5 = 0;
}

int main(void)
{
  while(1) {
    if (Ereignis1) {
      reset_vars();
    }
    if (Ereignis2) {
      reset_vars();
    }
    if (Ereignis3) {
      reset_vars();
    }
  }
}

Wenn es mehrere gleichartige Variablen sind bietet es sich übrigens an, 
daraus ein Struct oder Array zu machen statt alle einzeln anzulegen. 
Aber der Code ist ja nur ein Beispiel.

[Rufus Τ. F. (rufus)]

Fabian O. schrieb:
> int main(void)
> {
>   while(1) {
>     if (Ereignis1) {
>       reset_vars();
>     }
>     if (Ereignis2) {
>       reset_vars();
>     }
>     if (Ereignis3) {
>       reset_vars();
>     }
>   }
> }

Warum kein logisches OR verwenden?

[Progger (Gast)]

Peter II schrieb:
> das ist zwar richtig, aber für 5 Variablen würde ich das nicht als
> sinnvoll ansehen. Hier ist wirklich die einfachste Lösung die Variablen
> global zu machen.

Die "einfachste" Lösung ist es schon, aber sicher nicht die Beste. 
Globale Variable soll man nicht verwenden. Die bringen ordentlich 
Probleme mit sich. Für "quick'n'dirty" können sie ab und zu ganz 
praktisch sein. Aber warum soll man sich in diesem Fall den Klotz 
"globale Variable" an das Bein binden, wenn es doch auch einfach 
ordentlich geht?

[Peter II (Gast)]

Progger schrieb:
> Aber warum soll man sich in diesem Fall den Klotz
> "globale Variable" an das Bein binden, wenn es doch auch einfach
> ordentlich geht?

der übergeben von Variabeln kosten auch zeit (bei einem kleinen AVR 
durch aus relevent). Außerdem sieht so so gleich den RAM verbraucht. 
Damm muss man sich auch noch um das init kümmern, das braucht man bei 
globalen auch nicht.

auf einem PC verwende ich auch keine Globalen variablen, auf einem AVR 
schon.

[Karl H. (kbuchegg)]

Peter II schrieb:

> der übergeben von Variabeln kosten auch zeit (bei einem kleinen AVR
> durch aus relevent).

Es kommt immer drauf an, wieviele Argumente man hat, welche Datentypen 
involviert sind, wie oft die Funktion aufgerufen wird, wie zeitkritisch 
das ganze ist, ....

> auf einem PC verwende ich auch keine Globalen variablen, auf einem AVR
> schon.

Yep. Auf einem AVR muss man schon mal die Krot aus praktischen Gründen 
schlucken.
Nichtsdestotrotz MUSS der TO lernen, wie Argument Passing funktioniert. 
Denn für alles und jedes globale Variablen zu machen, ist dann ebenfalls 
der falsche Ansatz

void puts()
{
  while( global_arg_to_puts )
  {
    global_arg_to_putc = *s++;
    putc();
  }
}


int main()
{
  ....

  global_arg_to_puts = "Hallo world";
  puts();

  global_arg_to_puts = "Juhu";
  puts();

  sprintf( buffer, "%d", i );
  global_arg_to_puts = buffer;
  puts();

das kanns ja offensichtlich nicht sein.

[jack (Gast)]

ich würd jetzt gerne einen blöden Kommentar schreiben, von wegen C-Buch 
und Stringzuweisung, aber ich weiß ja was du mit dem Beispiel sagen 
willst :-)

[Fabian O. (xfr)]

jack schrieb:
> ich würd jetzt gerne einen blöden Kommentar schreiben, von wegen C-Buch
> und Stringzuweisung

Die "Stringzuweisung" wäre in Ordnung, sofern global_arg_to_puts als 
char* definiert ist. Die puts-Funktion würde allerdings nicht 
funktionieren ... ;-)

Man sollte übrigens deutlich zwischen globalen Variablen (ohne static) 
und Modulvariablen (mit static) unterscheiden. Letztere sind kein 
Teufelszeug und wird man in jedem realen, vernünftig geschriebenen 
C-Programm brauchen, egal ob µC oder PC.

[Peter II (Gast)]

Fabian O. schrieb:
> Letztere sind kein
> Teufelszeug und wird man in jedem realen, vernünftig geschriebenen
> C-Programm brauchen, egal ob µC oder PC.

doch sind sie, spätestens wenn man mit Threads anfängt merkt man das 
globale (egal welche) nicht wirklich gut sind.

[Fabian O. (xfr)]

Wo speicherst Du denn stattdessen die Daten?

[Peter II (Gast)]

Fabian O. schrieb:
> Wo speicherst Du denn stattdessen die Daten?

was für daten? z.b. in stucts.


struct Moduldaten md;
ModulInit( &md );

ModulMachWas( &md, "was soll ich machen?" );

ModulClose( &md );

[Fabian O. (xfr)]

struct Moduldaten md;

ist doch eine globale Variable? Oder legst Du die in der main-Funktion 
auf dem Stack an? Oder mit malloc? Wenn ja, was soll daran besser sein?

[Peter II (Gast)]

Fabian O. schrieb:
> Oder legst Du die in der main-Funktion
ja

> auf dem Stack an? Oder mit malloc?
ist egal

> Wenn ja, was soll daran besser sein?
ich kann das Modul mehrfach gleichzeig z.b. in Thread nutzen.

[jack (Gast)]

Also praktisch "pseudo-objektorientiert", fehlen nur noch 
Funktionszeiger in der Struktur :-)

Aber reden wir hier von PC oder uC?

[Fabian O. (xfr)]

Peter II schrieb:
> ich kann das Modul mehrfach gleichzeig z.b. in Thread nutzen.

Das hat ja nichts damit zu tun, wo Du die Variable anlegst. Du machst 
also folgendes:

int main(void)
{
  struct Moduldaten md;

  ModulInit( &md );
  ModulMachWas( &md, "was soll ich machen?" );
  ModulClose( &md );
}

Mein Frage ist, warum nicht so?

static struct Moduldaten md;

int main(void)
{
  ModulInit( &md );
  ModulMachWas( &md, "was soll ich machen?" );
  ModulClose( &md );
}

Vorteil:
- Der Compiler kann den Speicherverbrauch ermitteln.
- Die Daten belegen keinen Platz auf dem Stack (gerade am PC relevant, 
wenn die Struktur groß ist und der Stack begrenzt).
- Du kannst ModulMachWas() auch von anderen Funktionen in main.c aus 
aufrufen, ohne dass der Funktion &md übergeben werden muss (darum ging 
es ja im Prinzip im Ausgangspost).

Nachteil:
- Mir fällt keiner ein?

[Peter II (Gast)]

Fabian O. schrieb:
> Nachteil:
> - Mir fällt keiner ein?

so wie du es jetzt gemacht hast es es ja ok, wenn aber das

static struct Moduldaten md;

in der Modul.c datei steht, dann wird es blöd.

[Fabian O. (xfr)]

Das ist ein anderes Thema, nämlich ob man von dem Modul mehrere 
Instanzen braucht oder nicht. Wenn man garantiert nur eine Instanz davon 
hat/braucht, dann kann man sich das Übergeben des Zeigers auf die Daten 
bei jedem Funktionsaufruf sparen. Bei Mikrocontrollern ist das meiner 
Erfahrung nach meistens der Fall ...

In Anwendungen, bei denen man mit mehreren Modulen mit mehrfachen 
Instanzen zu tun hat, fährt man wahrscheinlich mit C++ besser, denn da 
ist die Objektorientierung gleich eingebaut.