4. Modulare Programme - Wie?

Modulare Programme - Wie?

  • E

    Hiya,

    Ich schreibe momentan einen kleinen IRC-Bot in C.
    Dabei würde ich gerne sozusagen 'Module' verwenden.

    Also ich hab meinen IRC-Bot mit seinen ganzen Funktionen.
    Da ich für bestimmte Zwecke bestimmte Funktionen deaktivieren will, muss ich das ganze ja irgendwie modular machen? -> Damit man den Bot anpassen kann, und er nich unnütig Resourcen frisst...

    Vielleicht sowas ähnliches wie bei Linux, dass man dann ein Modul mit einem Kommando laden kann.

    Natürlich könnte ich in ne Config file mit yes/no das eine oder andere de/Aktivieren und dann im Programm mittels if schauen ob es verwendet werden soll.
    Ich meine es aber so richtig modular 😃

    Dabei muss es jetzt nichtmal eine Scriptsprache dafür sein...

    Was mir unklar ist, wie sieht so ein Modul aus und wie wird es ins Programm integriert?
    Was gibt es da für Technicken?
    Tipps? Links?

    Wenn man das mit Modulen macht, läuft das Programm genau so schnell als ob es richtig 'drin' wär?

    0
  • P

    Was ich unter modularer Programmierung verstehe (das mag nicht mit dem Fachbegriff aus der Informatik übereinstimmen)

    1. Klares und effizientes Design durch Optimierung der Algorithmik.
    2. Klare Zergliederung des Problems in überschaubare orthogonale Teilprobleme.
    Dies führt nebenbei zu einer guten der Wartbarkeit, und Optimierbarkeit
    (An solchen Programmteilen (Modulen) kann man dann auch die Bottlenecks identifiziern und eliminieren.)

    Wenn man es in die entsprechenden den Telprobleme zergliedert kann man die als Module einzeln mit klaren Schnittstellen
    implementieren. Diese Implemantation reicht von Aufteilen in C-Files eines Projektes bis hin zuim Auslagern in dll´s zwecks Wiederverwendbarkeit in vielen Projekten. Wenn man es in DLL´s auslagert, bekommt man als Nebeneffekt auch die Möglichkeit, das man während des Betriebs passende Funktionalitäten nachladen kann.

    Primär ist die Modularisierung ein Design-Process.
    Erst in der Umsetzung wird daraus auch ein Coding-process.

    0
  • R

    also eine Methode waere folgende

    jedes Modul hat eine bestimmte init-Funktion, die du aufrufst, wenn das Modul geladen wird. Diese Funktion ruft eine Funktion im Programm auf, um die Funktionen im Modul zu laden. Die Funktionen speicherst du dann in irgend welchen Listen und fuehrst die nach einander aus, an den entspr. Stellen

    weil mein geschreibe sicher recht unverstaendlich ist, hier mal nen bissel Pseudo-Code

    //im Modul:
void quit(int e_code) {
  fprintf(stderr,"exit code: %d pid: %d\n",e_code,getpid());
}

// wird beim laden des Moduls aufgerufen und registriert die Funktionen
void init(void) {
  register_function("quit",quit);
}

//im Programm
struct mod_funcs {
  size_t size;
  void *funcs[100];
};

mod_funcs functions[100 /*nummer der zu ueberladenen Funktionen*/];

//wandelt einen string in ein size_t Wert um
size_t hash(const char *str);

//registriert die funktionen
void register_function(const char *function_name,void *fn) {
  mod_funcs *mf=functions[hash(function_name)];
  mf->funcs[mf->size<100?mf->size++:error("too many modules")]=fn; //hehehe :)
}

//ruft die Funktionen auf und uebergibt einen Parameter
void call_functions_with_param(const char *name,int e) {
  mod_funcs *mf=functions[hash(name)];
  for(size_t i=0;i<mf->size;++i)
    mf->funcs[i](e);
};

//Programm eigene quit Funktion
void quit(int e_code) {
  call_functions_with_param("quit",e_code);
  exit(e_code);
}

//Funktion wird aufgerufen, wenn ein Modul geladen werden soll
void load_modul(const char *path) {
  mod_handle *mh=load_so(path);
  call_fn(mh,"init");
  close_so(mh);
}

    wenn du Linux nutzt, kannst du die Module als so abspeichern und mit den Funktionen dlopen(3) oeffnen und auslesen und damit das Modul auf Funktionen des Hauptprogramms zugreifen kann, musst du -rdynamic als Option beim compilieren mit angeben.

    0
  • E

    Hmm, kannst du diesen Code etwas naeher erläutern? Blick da nich durch...
    Ab "mod_funcs functions[100 /*nummer der zu ueberladenen Funktionen*/]; "
    Wie wird die Funktion genau registriert?

    Edit:

    wenn du Linux nutzt, kannst du die Module als so abspeichern und mit den Funktionen dlopen(3) oeffnen und auslesen und damit das Modul auf Funktionen des Hauptprogramms zugreifen kann, musst du -rdynamic als Option beim compilieren mit angeben.

    Is das jetzt ne andere Möglichkeit oder auf die oben bezogen? wegen "als so"

    0
  • R

    Wie wird die Funktion genau registriert?

    die init Funktion ruft fuer jede Funktion des Moduls die Funktion register_function auf und uebergibt 1. wann die Funktion aufgerufen werden soll (im Beispiel bei "quit", kann aber auch was anderes sein zB. "startup", wo eben die Plugins arbeiten sollen) 2. einen Funktionspointer

    Is das jetzt ne andere Möglichkeit oder auf die oben bezogen? wegen "als so"

    jo, ist auf oben bezogen. so sind die Dynamisch Ladbaren Librarys in Linux.

    0
  • E

    Hmm, hast du vielleicht n konreten Link zu einer Howto oder so? Mir ist immer noch einiges Unklar.

    Hab mich schon weggegoogelt, aber das meiste mit DLL hab ich für win gefunden 😢

    0
Anmelden zum Antworten