wieder ein Problem.

Gibt es eine Möglichkeit, folgenes in C++ zu realisieren? (pseudocode)

int funk_A () {
 tu_was;
}

int main () {

  var test = "A"  
  funk_{test}();

}

oder auch:

class Klasse_A {

  ...

}

int main () {

  var test = "A"

  Klasse_{test} klasse;

  klasse->foobar();

}

ich habe keine Idee, wie man sowas machen könnte

Eventuell hilft Dir das Fabrikmuster weiter.

Modul_A_foo(); // aus Modul_A.so
Modul_B_foo(); // aus Modul_B.so
Modul_C_foo(); // aus Modul_C.so

heisen.

und die möcht ich nun der Reihe nach aufrufen.

sind die module von dir?

ja

dann lass die module alle von derselben basisklasse erben, die die entsprechenden methoden pure virtual bereitstellt. dann ists wurst, wie die klasse heisst, wird einfach über die basisklasse referenziert.

das musst du mir genauer erklären

das Wichtige ist, dass eben immer eine bestimmte Funktion aus allen Modulen aufgerufen wird.

if ereignis == bla
{
  Modul_A_foo();
  Modul_B_foo();
  Modul_C_foo();
}
else if ereignis == lala
{
  Modul_A_go();
  Modul_B_go();
  Modul_C_go();
}

habe mir schon geacht, aus jedem Modul eine Klasse zu Bilden, also

class Modul_A 
{
  int foo();
  int go();
}
class Modul_B 
{
  int foo();
  int go();
}
class Modul_C
{
  int foo();
  int go();
}

aber leider komm ich da auch nicht weiter

hm, kommst nich mit dlsym an die funktionen?

hm, kommst nich mit dlsym an die funktionen?

doch, aber was nützt mir das?

dlsym sucht dir die adresse zu ner funktion raus, die du als string übergeben kannst. den pointer kannst dir zurechtbiegen und entsprechend verwenden.

geht das auch mit klassen?

also

class foobar {
  ...
  int bla() {
    ...
  }
}

int main()
{
    ????
    handle = foobar;

    (*handle) test;
    test.bla();

}

das wär perfekt!

Lese doch mal was zum Thema Polymorphie bzw. virtuelle Methoden. Das sollte dir hier helfen.
http://tutorial.schornboeck.net/virtual.htm

Hallo,

Lese doch mal was zum Thema Polymorphie bzw. virtuelle Methoden. Das sollte dir hier helfen.
http://tutorial.schornboeck.net/virtual.htm

Hey, danke für den Link!
Klappt mit jetzt!

Andere Frage,

Brauche etwas in dieser Form:

array[0]["foo"] = "bla";
array[0]["bar"] = "bla";
array[1]["foo"] = "bla";
array[1]["bar"] = "bla";
array[1]["go"] = "bla";
array[2]["la"] = "bla";

also
array[ int ] [ string ] = string

Habs mit Maps versucht, aber bekomme die Definition nicht richtig hin.

?

std::vector<std::map<std::string, std::string> > array;

		 array[0]["bla"] = "foo";

bekomm ich immer einen Speicherzugriffsfehler.
Wenn ich die zweite Zeile rausnehme, gehts.

std::map<std::pair<int, std::string>, std::string> mMap;
// Beispiel:
mMap[std::make_pair(0, "foo")] = "bla";
mMap[std::make_pair(0, "bar")] = "blubb";
cout << mMap[std::make_pair(0, "foo")] << endl;
cout << mMap[std::make_pair(0, "bar")] << endl;

Wenn der Key mehrfach vorkommen soll (also, dass auch der string des pairs mehrfach gleich wäre), dann ist ne multimap zu nehmen.

Edit:
Oder so wohl doch besser so ^^:

std::vector<std::map<std::string, std::string> > array;
array.push_back(std::map<std::string, std::string>());
array[0].insert(make_pair("foo", "bla"));
array[0].insert(make_pair("bar", "blubb"));
cout << array[0]["foo"] << endl;

Du musst immer eine map pushen bevor du diese dann benutzen kannst und über einen Index darauf zugreifen kannst.

Greetz

bekomm ich immer einen Speicherzugriffsfehler.
Wenn ich die zweite Zeile rausnehme, gehts.

Klar, weil dein array zunächst leer ist. Ein Aufruf von array.resize(gewuenschte_groesse); vor dem Zugriff sollte das Problem lösen.

array.resize(gewuenschte_groesse)

AAAAAAAAAAAHHHHHHHHHHHHHHHHHHHHHHHHHHHHH!!!!!!!!!

Tausend Dank!
Werd mich doch noch ein wenig mit Vectoren/Maps beschäftigen müssen

std::vector<std::map<std::string, std::string> > array(10);
array[0] = std::map<std::string, std::string>();
array[0].insert(make_pair("foo", "bla"));

Greetz

Ist diese Zweile wirklich nötig? Sollte nicht schon der Konstruktor von std::vector dafür sorgen, dass die Konstruktoren der Elemente aufgerufen werden?

da ich bei der initialisierung aber die größe noch nicht weiss, ist resize schon genau das richtige

array[0] = std::map<std::string, std::string>();

Ist diese Zweile wirklich nötig? Sollte nicht schon der Konstruktor von std::vector dafür sorgen, dass die Konstruktoren der Elemente aufgerufen werden?

Jupp, wenn man die Größe angegeben hat ist die Zeile überflüssig. Da werden in meinem Beispiel 10 leere maps angelegt.
Bei der push_back-Methode, die ich auch einem ständigen resize evtl. bevorzugen würde, muss einmal eine map gepushed werden, da ist ja auch noch nichts initialisiert.

Greetz