C++ generische Parameterliste

[Philip K. (philip_k)]

Hallo,

ich habe da eine Problemstellung, bei der ich für ein paar Anregungen 
dankbar wäre.

Ich habe mehrere eigenständige SW-Module, die dafür gedacht sind, sowohl 
von der Komandozeile, als auch mit einem GUI-Frontend aufgerufen zu 
werden. Als Schnittstelle dient dabei eine Funktion, der ich die 
Paramter (entweder die kopierten CL-Parameter, oder eben von der GUI 
zusammengestellt) als vector<string> übergebe.

Jetzt hat zwar jedes Modul diese einheitlich definierte Schnittstelle, 
aber in der Regel unterschiedliche Parameter.
Damit ich bei Hinzufügen/Ändern eines Moduls nicht jedes Mal die 
Aufrufumgebung anpassen muss, ist mein Plan, dass jedes Modul über eine 
weitere Funktion seine Parameter bekannt machen kann. Diese Funktion 
soll eine Liste mit Descriptor-Objekten der möglichen Parameter liefen.
Ein solches Objekt z.B. folgende Informationen beinhalten:
- CL-Bezeichnung (z.B. -f für einen Dateinamen)
- Eine Kurzbeschreibung
- Ggf. eine ausführliche Beschreibung
- Den Typ (String, Int, Bool, ...)
- Default-Werte
- Für z.B. integer: Bereichs-Einschränkungen oder einzelne vorgegebene 
Werte
- Eine Liste auswählbarer Werte, die z.B. in einer GUI in einem 
Pull-Down menü erscheinen)
- Informationen welche Optionen sich gegenseitig ausschließen (Stichwort 
Radio-button). Dafür könnte man ja z.B. Objekte zu einer Gruppe 
zusammenfassen.
- ...

Ich suche jetzt nach eleganten Wegen eine solche Descriptor-Klasse 
aufzubauen. Eventuell wäre es auch sinnvoll für jeden Parameter-Typ eine 
eigene Klasse zu definieren und der gemeinsamen Basisklasse eine Funtion 
zu verpassen, mit der sich der Typ abfragen lässt (Ich denke da an sowas 
wie Qts QVariant).

Für kreative Vorschläge bin ich dankbar und offen.

Gruß

[Εrnst B. (ernst)]

Wenns erstmal nur um "Variant" geht, evtl:
http://www.boost.org/doc/libs/1_55_0/doc/html/variant.html

[Philip K. (philip_k)]

Kannte ich noch nicht. Sieht aber sehr brauchbar aus - danke!

[Karl Käfer (Gast)]

Hallo Philip,

Philip K. schrieb:
> Ich habe mehrere eigenständige SW-Module, die dafür gedacht sind, sowohl
> von der Komandozeile, als auch mit einem GUI-Frontend aufgerufen zu
> werden. Als Schnittstelle dient dabei eine Funktion, der ich die
> Paramter (entweder die kopierten CL-Parameter, oder eben von der GUI
> zusammengestellt) als vector<string> übergebe.
>
> Jetzt hat zwar jedes Modul diese einheitlich definierte Schnittstelle,
> aber in der Regel unterschiedliche Parameter.
> Damit ich bei Hinzufügen/Ändern eines Moduls nicht jedes Mal die
> Aufrufumgebung anpassen muss, ist mein Plan, dass jedes Modul über eine
> weitere Funktion seine Parameter bekannt machen kann.
> [...]
> Für kreative Vorschläge bin ich dankbar und offen.

Da gibt es auch Boost.Program_options oder auch sowas:

// compile:  LANG=C g++ -Wall -Wextra -ggdb -std=c++11 main.cpp

#include <iostream>
#include <string>
#include <vector>
#include <cstdlib>

using namespace std;   // pfui!1!


class ModuleBase { public: virtual void print(void) = 0; };
class ModuleFactory {};


class ModuleA: public ModuleBase {
private: int a;
public:
    ModuleA(int a): a(a) {}
    void print(void) { cout << "ModuleA: " << a << endl; }
};
class ModuleAFactory: public ModuleFactory {
public:
    static ModuleA* makeModule(vector<string> params) {
        for(unsigned int e = 0; e < params.size(); ++e) {
            if( params[e].compare( "-a" ) == 0 ) {
                return new ModuleA( atoi(params[e+1].c_str()) );
            }
        }
        return NULL;
    }
};


class ModuleB: public ModuleBase {
private: double b;
public:
    ModuleB(double b): b(b) {}
    void print(void) { cout << "ModuleB: " << b << endl; }
};
class ModuleBFactory: public ModuleFactory {
public:
    static ModuleB* makeModule(vector<string> params) {
        for(unsigned int e = 0; e < params.size(); ++e) {
            if( params[e].compare( "-b" ) == 0 ) {
                return new ModuleB( atof(params[e+1].c_str()) );
            }
        }
        return NULL;
    }
};


int main(int argc, char* argv[]) {
    vector<string> vec;
    vector<ModuleBase> modules;
    for(int i = 0; i < argc; i++) {
        vec.push_back( string(argv[i]) );
    }

    ModuleA* a = (ModuleA*)ModuleAFactory::makeModule(vec);
    ModuleB* b = (ModuleB*)ModuleBFactory::makeModule(vec);
    if(a != NULL) { a->print(); }
    if(b != NULL) { b->print(); }
}

Das ist jetzt auf die Schnelle gehackt und kann auch viel schöner 
gemacht werden. Natürlich kann man da statische help()-Methoden 
hinzufügen und die Module seriell in einen Array-Container packen, mit 
Templates arbyten oder ... Aber der eigentliche Trick ist, daß jedes 
Modul sich die für das Modul nötigen und nützlichen Parameter 
herauspickt und den Rest ignoriert.

HTH,
Karl

[Philip K. (philip_k)]

Hallo Karl,

Boost sollte ich mir wohl insgesammt mal näher ansehen, da scheints 
viele nützliche Dinge zu geben.

Zu Deinem Beispiel - Danke für die Mühe, aber das ist nicht ganz das was 
ich meinte.
Ich versuchs nochmal anders:

- Ein Programm (GUI, da wirds anschaulicher) wird mit einer 
erweiterbaren Anzahl von Modulen kompiliert. Diese Module haben eine 
einheitliche Aufrufschnittstelle aber unterschiedliche Parameter.
- Beim Programmstart wird von jedem Modul eine Instanz erstellt und ein 
paar Basisinformationen (Modulname etc.) abgeholt und in eine Liste 
(Combobox), dem Anwender zur Auswahl gestellt.
- Der Anwender wählt ein Modul aus und die Basisapplikation holt sich 
daraufhin von diesem Modul die verfügbaren Parameter und trägt sie in 
ein Config-Fenster ein.
- Der Anwender ändert ggf. Optionen und klickt auf einen Start-Button.
- Die Basisapplikation überreicht dem Modul die aktuellen Parameter als 
Strings über die einheitliche Aufrufschnittstelle und startet damit 
einen Ablauf.

Gruß
Philip

Karl Käfer schrieb:
> HTH,
??? :-)

[Klaus W. (mfgkw)]

Philip K. schrieb:
> - Der Anwender wählt ein Modul aus und die Basisapplikation holt sich
> daraufhin von diesem Modul die verfügbaren Parameter und trägt sie in
> ein Config-Fenster ein.

Sind die auswählbaren Parameter immer endlich (und ggf. auf eine mäßige 
Größe beschränkt), oder kommen auch welche vor in der Art "ganze Zahl" 
oder Gleitkommazahl zwischen -4.21 und +10.987"?
Beliebige Dateinamen?
Dann wäre "holt sich daraufhin von diesem Modul die verfügbaren 
Parameter" natürlich ganz anders zu interpretieren.

[Klaus W. (mfgkw)]

Philip K. schrieb:
>> HTH,
> ??? :-)

"Hope this helps"

[Sabine W. (sabine_w)]

Ich habe in einem C++-Kurs mal für ein Art modularen Synthesizer mit 
flexiblen Modulen gearbeitet, die sich beim Pogramm registrieren 
konnten, damit die GUI bzw. das Konsolenprogramm was damit anfangen 
konnten.
Als Beispiel der Anfang (die Includes mal weggelassen) eines solchen 
Moduls zur Hallerzeugung, jedes Modul registrierte seine Ein- und 
Ausgänge, damit die Module in der GUI miteinander verdrahtet und damit 
dann ein Ton erzeugt werden konnte:

//Statisches Objekt von der eigenen Klasse wird initialisiert, dient der Modul-Registrierung
CS_Gen_Hall& CS_Gen_Hall::own=*new CS_Gen_Hall((t_init)S_HALL);

//Initialisierungskonstruktor zur Modul-Registrierung 
CS_Gen_Hall::CS_Gen_Hall(t_init id) 
{
  CList_Module::Add_Modul(this,this->info(),id);
}

//normaler Konstruktor
CS_Gen_Hall::CS_Gen_Hall(void) 
{
  //Aus- und Eingänge des Hall-Moduls werden angelegt
  //hall ist Ausgang
  hall=CSig_Val::Output("Hall",this);

  //signal ist Eingang und liefert das Signal, auf das der Hall angewendet wird
  CSig_Val::Input(&signal,"Signal",this);

  //faktor ist die Abschwächung
  CSig_Val::Input(&faktor,"Abschwaech-Faktor",this);

  //delay ist die Verzögerung
  CSig_Val::Input(&delay,"Verzoegerung",this);
}

CS_Gen_Hall::~CS_Gen_Hall(void)
{
}

//Info zurückgeben
char * CS_Gen_Hall::info(void)
{
  return "Hallmodul";
}

//Verweis auf neue Instanz zurückgeben 
CS_Modul * CS_Gen_Hall::instanz(void) {
return new CS_Gen_Hall();
}

Sabine

[Philip K. (philip_k)]

Klaus Wachtler schrieb:
> Sind die auswählbaren Parameter immer endlich (und ggf. auf eine mäßige
> Größe beschränkt), oder kommen auch welche vor in der Art "ganze Zahl"
> oder Gleitkommazahl zwischen -4.21 und +10.987"?
Das sollte schon möglich sein. Deshalb dachte ich mir ja, dass ich eine 
Deskriptorklasse für jeden möglichen Datentyp (string, int float, bool, 
...)implementiere, die u.a. Auskunft darüber gibt, welche Werte erlaubt 
sind.