Funktionslisten erstellen und ausführen.

Ziel ist in etwa folgendes:

void void1()  #verbinde_mit_liste(1)
{
..
}
void void2()  #verbinde_mit_liste(1)
{
..
}
void void3()  #verbinde_mit_liste(2)
{
..
}

int main() 
{
run_liste(1);  // führt void1 und void2 aus
run_liste(2);  // führt void3 aus.
return 0;
}

Das Problem ist: ich weiß nicht genaus nach was für einem konstrukt ich hier genau suche... irgendwie sollte die Zuordnung innerhalb des Funktionskopfes zur Liste stattfinden.

dot

Was du suchst nennt sich switch-statement.

Leider nicht :(.

mir geht es darum, dass mit irgendeinem Compiler-Flag, oder etw. ähnlichem alle funktionen die mit liste_1 gekennzeichnet werden in liste_1 registriert werden. Wenn liste_1 irgendwo im Code aufgerufen wird, dann werden alle funktionen die mit #verbinde_mit_liste_1 markiert sind ausgeführt... zumindest ist dass das Ziel.

so ähnlich wie atexit(function) aus stdlib.h

Array von Funktions-Pointern. Evtl. sogar 2D

dot

wieso kann void1 nicht einfach void2 aufrufen?

Danke. Naja, Eure Antworten helfen nicht so richtig, warscheinlich, weil mir immer noch nicht ganz klar war, wie ich das ganze erklären soll, vielleicht auch weil es keine einfache Lösung (in C) gibt. Trotzdem Danke für die Bemühungen!

Im Prinzip möchte ich eine ereignisbasiertes Programm entwickeln. Dazu benötige ich eine Zuordnung der Handler zu den Ereignissen. (hier void1 -> run_liste1, void2->run_liste1, void3-> eun_liste2 void=handler run_liste=ereignis).

Im Prinzip kann ich dass in C von Hand schreiben:

void void1() 
{
..
}
void void2()
{
..
}
void void3()
{
..
}
void run_liste_1(){
void1;
void2;
}
void run_liste_2(){
void3;
}

int main()
{
run_liste_1;  // führt void1 und void2 aus
run_liste_2;  // führt void3 aus.
return 0;
}

Mein Wunsch ist allerdings, dass die Zuordnung der Handler zu den jeweiligen Events bei den Handlern, und nicht bei den Events stattfindet. D.H. das in void1 irgendwie festgelegt wird: "gehört zu liste_1" und mit dieser Info run_liste automatisch erstellt wird.

Ich bin mir unsicher... ist das irgendwie machbar?

dot

Dann mach eine Liste/ein Array aus Funktionspointern die du, wenn das Event eintritt, alle nacheinander aufrufst...

... denn das macht atexit() auch nicht anders.

Wutz

Meinst du sowas wie Array von Funktionslisten wie:

typedef void (*FP)(void);

void f11(void) {puts("f11");}
void f12(void) {puts("f12");}
void f13(void) {puts("f13");}
void f21(void) {puts("f21");}
void f22(void) {puts("f22");}

FP liste[][4]={{f11,f12,f13},{f21,f22}};

enum {RUNLIST1,RUNLIST2};

#define RUNLIST(i) { FP *f=&liste[i]; while( *f ) (*f++)(); }

int main()
{
  RUNLIST(RUNLIST1);
  RUNLIST(RUNLIST2);
  return 0;
}

Danke.