Variable im Funktionsnamen

Maddes

Hi,

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

Knuddlbaer

IMHO gibt es keine Funktionsnamen mehr in einem compilat.

Eventuell hilft Dir das Fabrikmuster weiter.

finix

Wenn du verrätst was du erreichen willst kann man dir bestimmt weiterhelfen...

Maddes

also es geht darum, dass ich mit dlopen etc. "Module" lade. in diesen Modulen soll es Funktionen geben, die

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.

thordk

sind die module von dir? 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.

Maddes

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

thordk

war quatsch was ich da geschrieben hab Oo erstmal richtig lesen, dann schreiben ^^

hm, kommst nich mit dlsym an die funktionen?

Maddes

hm, kommst nich mit dlsym an die funktionen?

doch, aber was nützt mir das?

thordk

#include <iostream>

int foo(int bar)
{
   return 42 + bar;
}

int main()
{
    int (*handle)(int);
    handle = foo;

    int bar = (*handle)(23);

    std::cout << bar << std::endl;
}

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

Maddes

hi,

geht das auch mit klassen?

also

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

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

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

}

das wär perfekt!

Braunstein

Hallo,

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

Maddes

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.

Der Meister

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

?

Maddes

ja, so hatt ichs auch schon probiert, aber beim aufruf:

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.

Vellas

Er möchte ein Schlüssel-Wert-Paar als Key. 0 kommt bei dem Beispiel mehrfach vor, allerdings kommt der String nur einmal vor, da sollte es wohl eher so aussehen:

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

Der Meister

Maddes schrieb:

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.

Maddes

array.resize(gewuenschte_groesse)

AAAAAAAAAAAHHHHHHHHHHHHHHHHHHHHHHHHHHHHH!!!!!!!!!

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

Vellas

Man kann die Größe auch gleich im Konstruktor angeben, dann kann man sich das resize ersparen:

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

Der Meister

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?

Maddes

ah okay.
gut zu wissen.

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

Vellas

Der Meister schrieb:

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