Funktionen als Parameter

Matrim

Hallo,

ich möchte gern eine Klasse erstellen, welche beliebige Werte in Dateien schreibt. Soweit so gut.

Nun würde ich aber gern haben, dass eine Client-Klasse sich zum Schreiben von Werten so anmeldet, dass sie ihre entsprechende get-Methode (des zu schreibenden Wertes) übergibt, eventuell mit entsprechenden Datentyp, um das binäre Schreiben dann zu erleichtern/ermöglichen. So dass die Schreibeklasse dann je nach Konvention die entsprechenden Werte dann OnDemand abrufen kann.

So ein get-Methode kann z.B. auch mit einem index als Parameter aufgerufen werden, so dass die Schreibeklasse z.B. die Werte getMethodeA(1), getMethodeB(1), getMethodeA(2), getMethodeB(2), ... , getMethodeA(100), getMethodeB(100) ohne Clientbemühungen ausgeben kann.

Ist soetwas möglich? Wenn ja, wie geht das oder wo müsste ich mich da informieren?

Danke im Voraus,
Mat.

BorisDieKlinge

Google mal nach funktionzeiger;)

da kannst funktionen wie objekte/zeiger behandeln und je nach bedarf wechseln

TomasRiker

Google lieber nach "Methodenzeiger", denn Funktionszeiger sind noch aus C und können nur für freie Funktionen und statische Methoden verwendet werden.

Airdamn

kannst auch hier im Forum "googlen", hier gabs auch schon einige Threads zum Thema...

*D*Evil

www.function-pointer.org

bwbg

Mit meinen stümperhaften Kenntnissen hätte ich eine abstrakte Basisklasse (als Interface) definiert und dann entsprechende Ableitungen für die gewünschten TypeHandler. Instanzierte Objekte der verschiedenen Handler dann in eine std::map gesteckt und bei Bedarf den entsprechenden aufgerufen.

Grüße...

Heiko

*D*Evil

Das Problem bei Methodenzeigern ist, dass du ja das Objekt mit angeben musst, auf das sich die Funktion berufen soll.

Wenn du allerdings folgendes ist, hast du glück

class foo
{
public:
    foo(std::size_t id) : m_id(id) {}

protected:
    typedef bool (foo::*fnCall)(std::size_t, void*);  
    void register_call(std::size_t id, fnCall call) { m_func[id] = call; }
    bool handle_call(std::size_t id, void* data) { std::map<std::size_t, fnCall>::iterator it = m_func.find(id); return (it != it.end() ? (*this.*(*it).second)(m_id, data));

public:
    void show(std::ostream& out) { out << handle_call(10, "Das ist ein Test"); << std::endl;

private: 
    std::map<std::size_t, fnCall> m_func;
    std::size_t m_id;
};

class bar : public foo
{
public:
    bar() : foo(1) { register_call(10, static_cast<fnCall>(&bar::use_a)); }

protected:
   void use_a(std::size_t id, void* data)
   { std::cout << id << " | " << static_cast<const char*>(data) << std::endl; }
};

Sieht bescheuert aus ... geht aber