Funktion neu starten

Chekow

Hallo!

Ich bin mit c noch nicht sehr erfahren und habe eine Frage:

Kann man Funktionen generell neustarten?

Der Hintergrund ist folgender: ich habe eine Funktion, welche intern mit statischen Variablen arbeitet.
Kann man diese irgendwie wieder "von vorn" ausführen?

Hier ein Beispiel:

#include <stdio.h>

int funktion()
{
  static int i = 0;
  i++;
  return i;
}

main()
{
  //Funktion beispielsweise zweimal aufrufen:
  printf("%d \n", funktion());
  printf("%d \n", funktion());
  //Jetzt moechte ich die Funktion eigentlich nochmal von vorn aufrufen:
  printf("%d \n", funktion()); //??
}

Noch besser wäre es, wenn dies mit einer kompletten c-Datei funktionieren würde, die ich aus einer anderen c-Datei starte. Ist klar, was ich meine?

Danke schön!

chekow schrieb:

Hallo!

Ich bin mit c noch nicht sehr erfahren und habe eine Frage:

Kann man Funktionen generell neustarten?

Der Hintergrund ist folgender: ich habe eine Funktion, welche intern mit statischen Variablen arbeitet.
Kann man diese irgendwie wieder "von vorn" ausführen?

Hier ein Beispiel:
#include <stdio.h>

int funktion()
{
  static int i = 0;
  i++;
  return i;
}

main()
{
  //Funktion beispielsweise zweimal aufrufen:
  printf("%d \n", funktion());
  printf("%d \n", funktion());
  //Jetzt moechte ich die Funktion eigentlich nochmal von vorn aufrufen:
  printf("%d \n", funktion()); //??
}
Noch besser wäre es, wenn dies mit einer kompletten c-Datei funktionieren würde, die ich aus einer anderen c-Datei starte. Ist klar, was ich meine?

Danke schön!

Mach dich mit Schleifen vertraut. Diese wird 100 Mal ausgeführt:

int i;
for (i = 0; i < 100; ++i)
{
 printf("%d \n", funktion());
}

Diese unendlich:

while (1)
{
 printf("%d \n", funktion());
}

nwp2

Keine Ahnung was obiger Beitrag mit dem Thema zu tun hat.

Soweit ich weiß gibt es so ein Reset statischer Variablen nicht. Ist einfach nicht vorgesehen. Stattdessen musst du es umgehen indem du eine Funktion schreibst die die statische Variable auf den Anfangswert setzt. Wenn soetwas sinnvoll ist sollte in der entsprechenden C-Datei auch eine solche Funktion vorhanden sein, wenn nicht musst du sie wohl selber schreiben.

Chekow

Hallo nwp2,

Danke für die Antwort. was genau meinst du mit

Stattdessen musst du es umgehen indem du eine Funktion schreibst die die statische Variable auf den Anfangswert setzt.

?

Kann ich "von außen" irgendwie doch noch auf statische Variablen zugreifen, um sie wieder zurück zu setzen?

Gruß,
Chekow

chekow schrieb:

Ist klar, was ich meine?

nö evtl. so

#include <stdio.h>

int global_i = 0;

int function()
{
  /*global_i++;
  return global_i;*/
  return ++global_i;
}
int reset()
{
  global_i=0;
}

main()
{
  //Funktion beispielsweise zweimal aufrufen:
  printf("%d \n", funktion());
  printf("%d \n", funktion());
  //Jetzt moechte ich die Funktion eigentlich nochmal von vorn aufrufen:
  reset();
  printf("%d \n", funktion()); //??
}

ups z.11 int in void tauschen

noobLolo schrieb:

ups z.11 int in void tauschen

xD jedes mal machst einen fehler. kann es sein dass du nervös bist?

Chekow schrieb:

Kann ich "von außen" irgendwie doch noch auf statische Variablen zugreifen, um sie wieder zurück zu setzen?

nee, aber du kannst ein resetflag mitgeben, so etwa:

int funktion (int reset)
{
  static int i;
  if (reset)
    i = 0;
  return i++;
}

^^ wenn du die funktion nun mit einem wert !=0 aufrufst, wird die static-variable wieder zurückgesetzt.

xD jedes mal machst einen fehler. kann es sein dass du nervös bist?

ach wenns nur einer wär...

int main(void)
statt
main()

man bräuchte eine virtuelle caffee kasse wo man für jeden beitrag mit fehler ne münze rein packt

evtl. sollte ich sie mir einfach nochmal durchlesen bevor ich sie poste und nicht danach, dann ist es immer schon zu spät.

nwp2

Was ich eigentlich meinte ist sowas:

int funktion()
{
  static int first = 1;
  static int i = 0;
  if (first){
    first = 0;
    return (int)&i;
  }
  return i++;
}

Beim ersten Funktionsaufruf gibt die Funktion nicht 0 sondern die Adresse von i zurück. Die kannst du dir irgendwo hinspeichern und bei Bedarf überschreiben. Ansonsten verhält sie sich ganz normal.

nwp2 schrieb:

int funktion()
{
  static int i = 0;
  if(i++!=0)
    return i;
  return (int)&i;
}

(int)&i

pfui

nwp2 schrieb:

Was ich eigentlich meinte ist sowas:
int funktion()
{
  static int first = 1;
  static int i = 0;
  if (first){
    first = 0;
    return (int)&i;
  }
  return i++;
}
Beim ersten Funktionsaufruf gibt die Funktion nicht 0 sondern die Adresse von i zurück. Die kannst du dir irgendwo hinspeichern und bei Bedarf überschreiben. Ansonsten verhält sie sich ganz normal.

^^das ist doch der grösste blödsinn, den ich seit langem hier gelesen habe. zuviel gekifft heute? *fg*
gib die adresse doch immer zurück:

int *funktion (void)
{
  static int i = -1;  // -1, weil wir bei 0 starten wollen
  i++;
  return &i;
}

int main (void)
{
   for (;;)
   {
      int *p = funktion();
      if (*p == 10)  // 0...9
         *p = 0;
      printf ("%d\n", *p);
   }
}

noobLolo schrieb:

evtl. sollte ich sie mir einfach nochmal durchlesen bevor ich sie poste und nicht danach, dann ist es immer schon zu spät.

Guckst du Button Vorschau.

pointercrash**

nwp2 schrieb:

Was ich eigentlich meinte ist sowas:
return (int)&i;  :open_mouth: }

Soll ich jetzt lachen oder weinen?
Du weißt schon, daß dieser cast kriminelles Potential hat, mal davon abgesehen, daß er nicht explizit dastehen muß, sondern bereits implizit durch den Rückgabetyp erfolgt?

pointercrash() schrieb:

...mal davon abgesehen, daß er nicht explizit dastehen muß, sondern bereits implizit durch den Rückgabetyp erfolgt?

den cast braucht man schon, wenn man einen 'int*' in einen 'int' quetschen will. C ist zwar 'weakly typed', aber so schlimm nun auch wieder nicht.

nwp2

Was habt ihr denn? Es ist ein fieser Hack, aber ihr habt doch sonst auch nichts dagegen. Ich finde ein int global_i = 0; und die buffer[wirdschonreichen] viel schlimmer, vor allem letztere, weil sie nicht funktionieren.

Der Sinn war auch, dass man funktion so weiterverwenden kann wie es schon im Code drinsteht, ohne den Rückgabetyp oder Parameter zu ändern. Aber gut, war in dem Fall wohl unnötig.

nwp2 schrieb:

Es ist ein fieser Hack, aber ihr habt doch sonst auch nichts dagegen.

haben wir wohl! einen pointer in einen int zu casten ist unportabel wie's schlimmer kaum geht. ich als unreg darf solchem unsinn schreiben, aber du, als registrierter mit einer gewissen posting-anzahl, solltest langsam darauf achten, dass du den noobs keinen quatsch beibringst. je höher dein zähler, desto mehr gewicht haben deine antworten in den augen der leser.

nwp2 schrieb:

Ich finde ein int global_i = 0; und die buffer[wirdschonreichen] viel schlimmer, vor allem letztere, weil sie nicht funktionieren.

ein 'int global_i;' wäre hier doch garnicht so verkehrt.

Man könnte den Threaderöffner ja mal fragen, warum die Variable unbedingt statisch sein muß und dazu auch noch versteckt, in einer Funktion.

Man könnte den Threaderöffner ja mal fragen, warum die Variable unbedingt statisch sein muß und dazu auch noch versteckt, in einer Funktion.

ich weiß die antwort es war nwp2 der uns das elegant ohne globale variable zeigen wollte

Chekow

Ok, danke schön an alle, ich denke, dass ich das Problem damit einigermaßen in den Griff bekommen kann.

Was ich mit den "ganzen Dateien" zu Anfang meinte war, dass ich ein Programm habe (welches nur aus einer Datei besteht) und aus ein paar Parametern einen Wert berechnet. (Es handelt sich um eine Monte-Carlo-Simulation, daher ist der Code etwas umfangreicher.)
Das würde ich gern aus einem anderen Programm steuern, um viele Werte in Serie "aufnehmen" zu können und dafür wäre es hilfreich, das ganze Programm neuzustarten, mit den Tipps hier kann ich das aber realisieren, denke ich.

Gruß und noch ein schönes WE,

Chekow