ich probiere gerade für eine templateklasse eine allgemeine methode zu definieren die dann über ein array mit parametern gefüttert wird.

Ich habe ein template mit unterschiedlichen datentypen welches von einer basisklasse erbt. Ich möchte dann mithilfe dieser basiklasse eine art wrappermethode auf das template schreiben, die ein abstraktes array von typen nimmt um die eigentlichen templatemethoden (mit den zu diesem zeitpunkt nur dem template bekannten parametern) aufzurufen und dazu die parameter aus dem array zu übernehmen.

die frage ist ob sowas funktioniert

//not compiled/ not tested

myfunc(void** args)
{
   myinnerfunc
   (
      (int)args[0],
      (std::string)args[1],
      (float)agrs[2]
   );
}

template<typename t1, typename t2, ...>(t1,t2,...)
..

main()
{
   void** data = new void*[3];
   data[0] = 20;
   data[1] = &std::string("x");
   data[3] = 0.1f;

   mytype<int,std::string,float>::myfunc(data);
}

oder inwieweit ich das abändern muss, dass das klappt.

1.) Es gibt gute Gruende, die gegen deinen Bedarf einer solchen Funktion sprechen.
2.) Welches Problem soll geloest warden?
3.) std::function

void** data = new void*[3];

wat

Egal was du bauen möchtest: void* ist in der Regel (und bei C++11 noch viel mehr) ein Zeichen für kaputtes Design. Gerade variadic templates sollten den Bedarf für Sachen wie void** praktisch komplett eliminieren. Wenn es unbedingt sein muss mit der "allgemeinen Methode", dann schau dir boost::any an und stopf dort parametrisierte std::functions rein. Danach baust du dir eine variadic template function invoke wo du dann intern einen Cast machst von boost::any zu eben der function mit der gleichen Signatur und rvalue references für die Übergabe der Parameter.

$edit$: Mein Post liest sich, als ob ich zu viel auf den Kopf gefallen wär

$edit$: Mein Post liest sich, als ob ich zu viel auf den Kopf gefallen wär

Den letzten Satz solltest du noch einmal überarbeiten.

&std::string("x")

Ganz falsch. Die Adresse einer Temporary zu nehmen, ist gar nicht schlau. Nur weil VC++ das erlaubt, heißt das nicht, dass das an sich viel Sinn macht.

1.) Es gibt gute Gruende, die gegen deinen Bedarf einer solchen Funktion sprechen.

1. anscheinend nicht sonst hätte ich die Frage ja nicht gestellt

knivil schrieb:

3.) std::function

2. C++ 11

knivil schrieb:

blurry333 == Pria ?

3. mit sicherheit nicht

boost::any

4. ich benutze kein boost, es gibt immer einen weg das selber zu lösen

variadic templates sollten den Bedarf für Sachen wie void** praktisch komplett eliminieren

5. statisch, daher schlicht unbrauchbar!

so und wie so oft nochmal so dass es auch jeder versteht

class mybasictemp
{
   public:
     virtual void invoke(??* args);
};

template<typename t1, typename t2 ... typename n> //variable 1-n
class mytemp : mybasictemp
{
   public:
      void invoke(t1, t2 ... n);
      virtual void invoke(??* args) override;
};

main()
{
   std::map<std::string, mybasictemp> temps = std::map<std::string, mybasictemp>();
   temps["test(1)"] = mytemp<int>();
   temps["test(3)"] = mytemp<int, std::string, float>();

   ??* args //<- from a source that dosent matter in this example eg.
            //   a cmd, network or file stream as strings (converted to the types needed)

   std::string name //<- a name to the template to be called
   temps[name].invoke(args); //<- exception if array is too short
}

void** data = new void*[3];

Also allein schon diese Zeile zeigt, dass du dein Konzept nochmal grundlegend durchdenken solltest. Void* als Zwischenweg kann ich sogar noch akzeptieren, aber wenn jemand anfängt, void-Pointer aktiv zu allokieren läuft etwas total falsch.

Vielleicht solltest du mal erzählen, was der Hintergrund deines C++-Amoklaufs ist, damit man dir alternative Lösungen anbieten kann.

boost::any

4. ich benutze kein boost, es gibt immer einen weg das selber zu lösen

Man mag alles selbst lösen können, dies ist in der Regel aber weder aus wirtschaftlichen noch qualitativen Gründen sinnvoll. Zum einen braucht die eigene Implementation ("Das Rad neu erfinden") mehr Zeit, zum anderen kann man seinen eigenen Code selten so gut durch testen, wie ein großes Team dies kann.

Ich habe vielen schlechten Code gesehen der, der Tatsache geschuldet war, das einer meinte alles selbst bauen zu müssen. Dann auch noch meinte das sein Code schneller und sicherer als der Kram aus der C++ Standardbibliothek sei (z.B. ein Vektorersatz der furchtbar kompliziert aus Mehrfachzeigern zusammen gebaut war).

Selbst bauen ist nur dann sinnvoll, wenn man entweder es einmal richtig verstehen will (danach bitte wegschmeißen) oder wirklich einen Sonderfall hat in dem es eine bessere Lösung gibt.

http://ideone.com/GWAjvS