Parameter in Funktion speichern. Geht das überhaupt? C

[Attila C. (attila)]

Hallo

Ich möchte innerhalb einer main Schleife eine Funktion A aufrufen und 
dieser 3 Werte übergeben, z.b. mit Schiebereglern.

Wenn jetzt bei Funkion A alles geregelt ist möchte ich 3 Parameter einer 
Funktion B übergeben, mit den gleichen Schiebereglern.

Wie schaffe ich es dass Funktion A sich die letzten Werte "merkt" ohne 
dass die Werte überschrieben werden?

Wahrscheinlich ist es ganz einfach und ich stehe nur grade auf dem 
Schlauch. :-(

Danke für Hinweise!

[Fabian (Gast)]

Leider ist deine Frage nicht klar. Wenn Funktion A durch ist, wird diese 
verlassen und danach Funktion B aufgerufen. Wie kommt Funktion A ist 
wieder ins Spiel?!

[PTx (Gast)]

ein "static" vor die Variablen in A() schreiben.

[Attila C. (attila)]

Beide Funktionen werden dauernd aufgerufen! Durch einen Schalter z.B. 
könnte bestimmt werden für welche der Funktionen die Schieberegler grade 
gültig sind.

Ein static löst das Problem nicht da ja die Schieberegler weiter 
betätigt werden.

[Guest (Gast)]

Mir ist leider nicht klar, was es mit deinen Schiebereglern auf sich hat 
aber in C hast du drei Möglichkeiten:

1. Globale Variable

int hugo = 42;

void foo(void) {
  hugo++;
}

void bar(void) {
  hugo--;
}

int main(void) {
  hugo = 0;
  foo();
  bar();
}

2. Pass by value

void foo(int a) {
  a++;
}

int main(void) {
 int hugo; 
 hugo = 0;
 foo(hugo);
  // hugo is still zero
}

3. Pass by reference

void foo(int* a) {
  *a++;
}

int main(void) {
 int hugo; 
 hugo = 0;
 foo(&hugo);
  // hugo is now 1
}

[Rufus Τ. F. (rufus)]

Deine Beschreibung bleibt unklar.

[Attila C. (attila)]

Also:

1) Frage die Schieberegler ab.
2) Schreibe die Werte der Schieberegler in Funktion A solange bis:
3) Funktion B aktiv ist.Dann führe Funktion A mit den letzten 
übergebenen Parametern weiter aus.
4) Schreibe demnach die Werte der Schieberegler in Funktion B solange 
bis:
5) Funktion C aktiv ist. Dann führe Funktion A mit seinen 
(gespeicherten?) Parametern aus und führe B mit den letzten übergebenen 
Parametern weiter aus.
6) Schreibe demnach die Werte der Schieberegler in Funktion C.
...usw.....
7) Fang von vorne an.

[Ralf G. (ralg)]

Attila C. schrieb:
> Also:
Vielleicht ist dein Ansatz nicht der Richtige.

Ich habe das jetzt so verstanden:
Auf Grund eines bestimmten Ereignisses (Zeit abgelaufen, 10 Durchläufe, 
...)
sollen die Eingabeparameter mit einer weiteren/ der nächsten Funktion 
verarbeitet werden.

Da könnte man jeder Funktion zusätzlich ein Flag oder eine 
Statusvariable übergeben, welche(s) anzeigt, dass eine weitere Funktion 
aktiv ist und somit mit den letzten Werten weitergerechnet werden soll. 
'static' ist hier trotzdem nötig.

[A. S. (Gast)]

Indem Du zu den 3 noch einen vierten Parameter mitgibst, ob die 3 für 
Funktion A oder B gelten.

Alternativ die Parameter auf einen "Spezial-Wert" setzen. Z.B. -1 wenn 
sonst nur 0..100 gültig sind.

Und lokale Spiegel der Variablen ("static"), damit die letzten Werte 
gültig bleiben.

void FuncA(int X, int Y, int Z, int BoxChecked)
{
static int p[3];

   /* hier nur, wenn BoxChecked == 0, in B andersrum*/
   if(!BoxChecked)
   {
      p[0]=X;
      p[1]=Y;
      p[2]=Z
   }
   ... und hier nur noch p[0..2] verwenden
}

[Stefan K. (stefan64)]

Hier mein Vorschlag ohne static. Hat den Vorteil, dass Du ggf. 
verschiedene Functionen wiederverwenden kannst, wenn dort eigentlich 
dasselbe passiert.

typedef struct
{
  int p1;
  int p2;
  int p3;
} paramsTypeDef;

enum actualFunctionEnum
{
  isFunctionA = 0,
  isFunctionB,
  isFunctionC,
  isNoFunction,
}


void functionA (paramsTypeDef *pSavedparameters, *pActualParameters, int saveMyParams)
{
  // do code of A

  if (saveMyParams)
  {
    memcpy (pSavedparameters, pActualParameters, sizeof(paramsTypeDef));
  }
}


void functionBC (paramsTypeDef *pSavedparameters, *pActualParameters, int saveMyParams)
{
  // do code of B and C

  if (saveMyParams)
  {
    memcpy (pSavedparameters, pActualParameters, sizeof(paramsTypeDef));
  }
}


void main()
{
  paramsTypeDef paramsA;
  paramsTypeDef paramsB;
  paramsTypeDef paramsC;
  paramsTypeDef actualFaders;
  actualFunctionTypeDef actualFunction = isFunctionA;  
  int saveParams;

  while(1)
  {
    getfader(&actualFaders);
    saveParams = shouldISaveParams();
 
    switch (actualFunction)
    {
      case isFunctionA:
        functionA(&paramsA, &actualFaders, saveParams);
        if (saveParams) actualFunction = isFunctionB;
        break;

      case isFunctionB:
        functionB(&paramB, &actualFaders, saveParams);
        if (saveParams) actualFunction = isFunctionC;
        break;

      case isFunctionC:
        functionC(&paramsC, &actualFaders, saveParams);
        if (saveParams) actualFunction = isNoFunction;
        break;

      case isNoFunction:
        if (saveParams) actualFunction = isFunctionA;
        break;

      default:
        actualFunction = isFunctionA;  // you should never get here!
        break;
    } 
  }    // end of while(1)
}      // end of main()

Ich würde ggf. noch das Ändern der Parameter und das Processing 
voneinandern trennen (nicht oben implementiert).

Z.B.:
void changeParams (paramsTypeDef *pSavedparameters, *pActualParameters, 
int saveMyParams)
void processA/B/C(paramsTypeDef *pSavedparameters);

Für das Ändern der Parameter brauchst Du dann nur eine Function, weil 
die bei A,B,C exakt dasselbe tut.

Gruß, Stefan

[Axel S. (a-za-z0-9)]

Attila C. schrieb:

> Ich möchte innerhalb einer main Schleife eine Funktion A aufrufen und
> dieser 3 Werte übergeben, z.b. mit Schiebereglern.

Dunkel der Sinn deiner Rede ist. Schieberegler sind kein Konzept der 
Programmiersprache C. Variablen hingegen sind es. Und Werte, die man 
an Funktionen übergibt, nennt man in C (und nicht nur da) üblicherweise 
Funktionsparameter. Ach ja: "main Schleifen" gibt es in C auch nicht.

> Wenn jetzt bei Funkion A alles geregelt ist möchte ich 3 Parameter einer
> Funktion B übergeben, mit den gleichen Schiebereglern.

Wenn du zwei Funktionen mit den gleichen Parametern aufrufen willst, 
dann mach das doch einfach.

> Wie schaffe ich es dass Funktion A sich die letzten Werte "merkt" ohne
> dass die Werte überschrieben werden?

Wenn Funktion A so definiert ist, daß sie drei Parameter erwartet, dann 
werden diese Parameter aus Sicht der Funktion immer überschrieben. 
Aber der Aufrufer der Funktion hat ja volle Kontrolle darüber, wie er 
die Funktion aufruft. Wenn er zweimal die gleichen Parameter verwenden 
will, dann kann er das selbstverständlich tun.

> Wahrscheinlich ist es ganz einfach und ich stehe nur grade auf dem
> Schlauch. :-(

Davon ist auszugehen. So wie es sich mir darstellt, hast du noch nicht 
mal die Aufgabe verstanden.

[A. S. (Gast)]

Stefan K. schrieb:
> Hier mein Vorschlag ohne static. Hat den Vorteil, dass Du ggf.
> verschiedene Functionen wiederverwenden kannst, wenn dort eigentlich
> dasselbe passiert.

Ist das jetzt Satire, oder willst Du dem TO wirklich helfen?

Und für uns, könntest Du nochmal den Vorteil beschreiben, den der 
NV-Speicher auf dem Stack gegenüber static hat?

[Peter D. (peda)]

Du mußt Dir zuerst mal ein Bedienkonzept überlegen. Also wie die 
Funktionen A,B,C ausgewählt werden und wann die Schieberegler übernommen 
werden sollen.
Einfach so drauflos programmieren führt zu nichts.

Auch könnte es das Verständnis wesentlich erhöhen, wenn Du sagst, was 
A,B,C konkret machen sollen. Abstrakte Fragestellungen helfen nur selten 
weiter, mit Gedankenlesen tun sich hier viele schwer.

[Der Andere (Gast)]

Du solltest dir ein gutes C Buch besorgen und es durcharbeiten.
Werte speichert man in Variablen.
Funktionen dienen nur dazu irgendwas auszuführen, dazu brauchen sie oft 
Variablen und manipulieren sie, aber Funktionen "bewahren" im 
Allgemeinen keine Variablen auf.

[Einer K. (Gast)]

Der Andere schrieb:
> Funktionen dienen nur dazu irgendwas auszuführen, dazu brauchen sie oft
> Variablen und manipulieren sie, aber Funktionen "bewahren" im
> Allgemeinen keine Variablen auf.

So ist es.

In manchen Situationen vereinfachen lokale statische Variablen das 
Leben.

Allerdings:
Funktionen sollten ein reproduzierbares Verhalten zeigen. Also bei 
gleichen Parametern, immer das selbe Ergebnis bringen. Das macht sie 
leichter testbar und auch wiederverwendbar.

Wenn sie lokale statische Variablen beinhalten, kann das bei unachtsamer 
Verwendung zu unerwünschten Seiteneffekten führen.

Das wollen wir doch nicht!
Oder?

Einerseits ist das ein erlaubtes Sprachmittel, aber andererseits gilt 
auch der Spruch: "Wer einmal begriffen hat, wie ein Hammer funktioniert, 
für den sieht jedes Problem wie ein Nagel aus"

[Stefan K. (stefan64)]

Achim S. schrieb:
> Ist das jetzt Satire, oder willst Du dem TO wirklich helfen?

Wenn ich das nicht ernst meinen würde, hätte ich mir wohl kaum die Mühe 
gemacht.

> Und für uns, könntest Du nochmal den Vorteil beschreiben, den der
> NV-Speicher auf dem Stack gegenüber static hat?

* Bei static kannst Du die Werte nur innerhalb dieser Funktion benutzen.
  Meistens ist es aber sinnvoll, solche Parameter an mehreren Stellen
  verfügbar zu haben. Das kan static nicht leisten.

* Bei static kann die Funktion nur einmal mit genau diesen Parametern
  verwendet werden. Wiederverwendbarkeit ist damit ausgeschlossen.
  Das Problem des TO sieht aber danach aus, dass seine Schieberegler auf
  genau dieselbe Weise in 3 Funktionen in unterschiedliche Parameter
  gesichert werden.

Ob die Parameter A/B/C global oder in main() definiert werden, ist 
dagegen erstmal zweitrangig.

In C++ liesse sich das Ganze übrigens noch deutlich eleganter lösen.

Gruß, Stefan

[Attila C. (attila)]

Erst mal an alle: Vielen Dank!

Ralf G. Und Achim S. : Genau danach hatte ich gesucht! Danke!

Stefan K. : Danke, aber die Werte müssen nicht weiter verändert werden.

Axel Schwenke: Das ich eine Aufgabe die meinen eigenen Überlegungen 
entspringt nicht verstanden haben soll ist an Absurdität kaum zu 
überbieten!

Peter Danneger: Ich habe den wahren Zweck der Anwendung nicht 
beschrieben um mich nicht dem allseits beliebten Bashing in diesem Forum 
auszusetzen. Dieser Thread wäre, wie leider so viele hier, komplett 
off-topic gegangen! Ansonsten ist es ,wie so oft, wie mit dem 
Schuhe-zubinden: Es ist gar nicht so einfach zu beschreiben.

Der Andere: Die von Ralf und Achim vorgeschlagene Idee ist sicher nicht 
in einem C-Buch zu finden.

Noch einmal vielen Dank!

[Ralf G. (ralg)]

@ Attila C.
Mal noch ein später Hinweis:
Arduino F. schrieb:
> Allerdings:
> Funktionen sollten ein reproduzierbares Verhalten zeigen. Also bei
> gleichen Parametern, immer das selbe Ergebnis bringen.

Auch ich würde die berechneten Werte außerhalb der Funktion speichern 
und die Funktion, wenn die Werte nicht verändert werden sollen, gar 
nicht erst aufrufen.

Arduino F. schrieb:
> Das macht sie leichter testbar und auch wiederverwendbar.

Eventuell kann man dann Teile der Funktionen A, B, C, ... sogar noch 
zusammenfassen.

[Markus F. (mfro)]

Stefan K. schrieb:
> memcpy (pSavedparameters, pActualParameters, sizeof(paramsTypeDef));

wieso nicht

*pSavedParameters = *pActualParameters;

?? Das reduziert (mindestens) eine Fehlerquelle und erlaubt dem 
Compiler, so zu optimieren, wie er das für richtig hält (wenn auch in 
vielen Fällen dasselbe rauskommt).

Es ist schon sehr lange her, dass C keine struct-Zuweisungen 
k[a,o]nnte.