Wie erstellt man einen Container, der verschiedene Typen von Funktionszeigern in C++ enthält?

Question

Ich mache ein lineares genetisches Programmierungsprojekt, in dem Programme durch natürliche Evolutionsmechanismen gezüchtet und entwickelt werden. Ihre "DNA" ist im Grunde genommen ein Container (ich habe erfolgreich Arrays und Vektoren verwendet), die Funktionszeiger zu einer Reihe von verfügbaren Funktionen enthalten. Jetzt, für einfache Probleme, wie mathematische Probleme, könnte ich einen typdefinierten Funktionszeiger verwenden, der auf Funktionen zeigen könnte, die alle ein Doppel zurückgeben und alle als Parameter zwei Doppel annehmen.

Leider ist das nicht sehr praktisch. Ich muss in der Lage sein, einen Container zu haben, der verschiedene Arten von Funktionszeigern haben kann, zB einen Funktionszeiger auf eine Funktion, die keine Argumente annimmt, oder eine Funktion, die ein Argument benötigt, oder eine Funktion, die etwas zurückgibt Idee) ...

Gibt es eine Möglichkeit, dies mit jeder Art von Container zu tun? Könnte ich das tun, indem ich einen Container verwende, der polymorphe Klassen enthält, die wiederum verschiedene Arten von Funktionszeigern haben? Ich hoffe, dass jemand mich zu einer Lösung führen kann, weil das Umgestalten alles was ich bis jetzt getan habe, wird schmerzhaft sein.

Answer 1

Sie können nicht eine polymorphe Funktion in einer Klasse, da Funktionen setzen, die (oder zurück) nehmen verschiedene Dinge nicht auf die gleiche Art und Weise verwendet werden (mit derselben Schnittstelle), die etwas von Polymorphismus erforderlich ist.

Die Idee, eine Klasse von mit einer virtuellen Funktion für jede mögliche Funktion Art zu schaffen, Sie würden arbeiten müssen, aber seine Verwendung seltsam mir fühlt sich (ohne etwas über Ihr Problem zu wissen!): Welche Funktionen würden eine abgeleitete Klasse überschreiben ? Sind Ihre Funktionen nicht unkorreliert?

Wenn Ihre Funktionen nicht korreliert sind (wenn es keinen Grund gibt, sie als Mitglieder derselben Klasse zu gruppieren oder wenn sie statische Funktionen sind, da sie keine Membervariablen benötigen), sollten Sie sich für etwas anderes entscheiden. Wenn Sie Ihre Funktionen zufällig auswählen, könnten Sie einfach mehrere verschiedene Container haben, einen für den Funktionstyp, und dann einfach einen Container und dann eine Funktion auswählen.

Können Sie einige Beispiele für Ihre Funktionen erstellen?

Answer 2

Eine typische Idee für virtuelle Maschinen ist es, einen separaten Stack zu haben, der für die Übergabe von Argumenten und Rückgabewerten verwendet wird.

Ihre Funktionen können immer noch vom Typ void fn (void) sein, aber das Argument wird manuell übergeben und zurückgegeben.

Sie können etwas tun:

class ArgumentStack { 
    public: 
     void push(double ret_val) { m_stack.push_back(ret_val); } 

     double pop() { 
      double arg = m_stack.back(); 
      m_stack.pop_back(); 
      return arg; 
     } 

    private: 
     std::vector<double> m_stack; 
}; 
ArgumentStack stack; 

... so eine Funktion könnte wie folgt aussehen:

// Multiplies two doubles on top of the stack. 
void multiply() { 
    // Read arguments. 
    double a1 = stack.pop(); 
    double a2 = stack.pop(); 

    // Multiply! 
    double result = a1 * a2; 

    // Return the result by putting it on the stack. 
    stack.push(result); 
} 

Dies kann auf diese Weise verwendet werden:

// Calculate 4 * 2. 
stack.push(4); 
stack.push(2); 
multiply(); 
printf("2 * 4 = %f\n", stack.pop()); 

Folgst du?

Answer 3

Was Sie selbst erwähnt haben, kann wahrscheinlich durch einen Container std::function oder diskriminierte Union wie Boost::variant implementiert werden.
Zum Beispiel:

#include <functional> 
#include <cstdio> 
#include <iostream> 

struct F { 
    virtual ~F() {} 
}; 

template< class Return, class Param = void > 
struct Func : F { 
    std::function< Return(Param) > f; 
    Func(std::function< Return(Param) > const& f) : f(f) {} 
    Return operator()(Param const& x) const { return f(x); } 
}; 

template< class Return > 
struct Func< Return, void > : F { 
    std::function< Return() > f; 
    Func(std::function< Return() > const& f) : f(f) {} 
    Return operator()() const { return f(); } 
}; 

static void f_void_void(void) { puts("void"); } 
static int f_int_int(int x) { return x; } 

int main() 
{ 
    F *f[] = { 
    new Func<void>(f_void_void), 
    new Func< int, int >(f_int_int), 
    }; 

    for (F **a = f, **e = f + 2; a != e; ++ a) { 
    if  (auto p = dynamic_cast< Func<void>*  >(*a)) { 
     (*p)(); 
    } 
    else if (auto p = dynamic_cast< Func< int, int >* >(*a)) { 
     std::cout<< (*p)(1) <<'\n'; 
    } 
    } 
} 

Aber ich bin nicht sicher, ob das wirklich ist, was Sie wollen ...
Was denken Sie über Alf P. Steinbach Kommentar?