Ich habe eine abstrakte basis klasse: "M". Die hat nur wenige functionen, u.a. int getfuncs(void* begin). Diese function gibt eine liste an Name<->FunctionPointer zurück.
"M" gibts in meinem Programm und in meiner dynamischen bibliothek.

Ich habe eine andere klasse: "init". Die basiert auf "M". init hat viele eigene functionen. init redefiniert dann auch getfuncs(..). init ist in einer dynamishen bibliothek definiert.

Den header mit der definition/declaration von init hab ich dann nicht. Ich hab also gegeben:
M* pointer, der zu einer instanz von init pointet.
Ein Function pointer, der zu einer funktion(kein static, virtual, etc) von init pointet(<- diese function hat M nicht). (Oder Function-to-member pointer. ich bin noch am rumprobieren was besser ist)

Edit:
void* wird NUR in dem Codebeispiel verwendet! In meinem bisherigen code is alles normal!**

class M
{
public:
    virtual int getfuncs(void*** list) = 0;
};

// in anderem header der dynamischen bibliothek. den header hab ich NICHT
class init : M
{
private:
    int num;

    void set(int val) { num = val; } // diese
    int get() { return num; }

    virtual int getfuncs(void***) // overwrites
    {
        // tabelle irgendwie auffüllen. (würde ich ja selbst machen)
        return 2; // anzahl an funktionen.
    }
};

int main()
{
    // dlhandle: handle einder dynamischen bibliothek, wo init drin sitzt und Kaffee trinkt...
    M* something = make(dlhandle); // pointer auf init instanz (<- polymorphismus)

    // MFUNC sei ein functionspointer typ...
    void** flist;
    something->getfuncs(flist);

    MFUNC* initset = flist[0];
    MFUNC* initget = flist[1];

    initset(50);
    // usw... (verwendung)
}

Ich dachte dann mal, einfach ein function-pointer nehmen und den this* pointer manuell auf "something" setzen... ?

Anders ausgedrückt: Dein Design ist vollkommen unpassend für eine Sprache wie C++, du benutzt zu viele void*** , du hast deine Frage nicht richtig gestellt.
Wenn du irgendetwas dynamisches machen willst, dann nimm besser eine andere Sprache. Wobei das auch dort sinnlos ist.

Sag lieber, was du konkret erreichen willst, dann können wir dir eine bessere Lösung vorschlagen.

Ich will Klassen dynamisch laden können. Also zur ausführungszeit komponenten meines programs laden oder entladen. Die header kennen die anderen klassen natürlich nicht. Und virtuelle funktionen will ich auch nicht, da die etwas langsamer sind....

Google ist da ja nicht sooo hilfreich, weil es "*" ja immer als Platzhalte interpretiert.

Das Sternchen steht für Zeiger google "c++ pointer".

Aber für was brauche ich einen Zeiger auf einen Zeiger (oder sogar einen Zeiger auf Zeiger auf Zeiger"? Ich habe sowas bisher einmal gesehen und als Blackbox angesehen, für was braucht man sowas?

geht nicht schrieb:

Du willst ein Plug-In-System bauen?

Nicht ganz... Ich kann programme auf komponenten in dynamischen bibliotheken verteilen. Das program hat also eine liste an Komponenten, zB "Netwerk", "Spieler", "Karte", usw... (ich dachte, die könnten vielleicht noch unter-komponenten haben, unter-unter-komponenten, etc...).

http://www.boost.org/doc/libs/1_45_0/libs/bind/bind.html#with_function_objects

("Diese funktion als DIESE Klasse aufrufen")

[...]Und virtuelle funktionen will ich auch nicht, da die etwas langsamer sind....

Langsamer als was? Als ein ähnlicher Mechanismus von Dir selbst gebastelt? Wohl kaum. Für Plugins braucht man wohldefinierte Interfaces. Und dafür bieten sich unter C++ Klassen mit rein virtuellen Funktionen an.

lk schrieb:

[...]Und virtuelle funktionen will ich auch nicht, da die etwas langsamer sind....

Langsamer als was? Als ein ähnlicher Mechanismus von Dir selbst gebastelt? Wohl kaum. Für Plugins braucht man wohldefinierte Interfaces. Und dafür bieten sich unter C++ Klassen mit rein virtuellen Funktionen an.

Ich will ja nicht direkt Plugins machen.

Virtuelle funktionen sind einen ganz kleinen tacken langsamer als normale nicht-virtuelle funktionen. Ich werde auch viele funktionen in den plugins aufrufen, sehr oft...

Wenn du eine Fallunterscheidung brauchst, kannst du nicht auf virtuelle Funktionen verzichten, aber gleichzeitig keine Alternative ( if , switch , etc.) anbieten.

#include <map>
#include <iterator>
#include <functional>
#include <stdexcept>

class M
{
public:
    typedef std::map<std::string, std::function<void(void)> > MethodMap;
    typedef std::insert_iterator<MethodMap> Inserter;
    typedef MethodMap::const_iterator Iterator;

    virtual ~M(){};

    void init()
    {
        getfuncs(Inserter(methods_, methods_.begin()));
    }

    void Call(const std::string& method)
    {
        Iterator it = methods_.find(method);
        if (it == LastMethod())
            throw std::runtime_error("Unknown method name.");
        it->second();
    }

    Iterator FirstMethod() const
    {
        return methods_.begin();
    }

    Iterator LastMethod() const
    {
        return methods_.end();
    }

private:
    virtual void getfuncs(Inserter i) = 0;
    MethodMap methods_;
};

// irgendwo
class init : public M
{
public:
    void foo() { std::cout << "fooo\n"; }
    void bar() { std::cout << "baar\n"; }
private:
    void getfuncs(Inserter i)
    {
        i = std::make_pair("foo", std::bind(&init::foo, this));
        ++i = std::make_pair("bar", std::bind(&init::bar, this));
    }
};

int main() 
{
    M* m = new init; 
    m->init();
    std::cout << "available methods:\n";
    for(M::Iterator i = m->FirstMethod(), e = m->LastMethod();
        i != e; ++i)
    {
        std::cout << i->first << "\n";
    }

    std::cout << "call:";
    std::string method;
    std::cin >> method;
    try
    {
        m->Call(method);
    }
    catch(std::exception& e)
    {
        std::cout << e.what();
    }

    delete m;
    return 0;
}

edit: Jetzt bin ich mir doch nicht mehr sicher was du meinst. Wenn es dir immer nur um die get und set geht, dann ist das tatsächlich ganz einfach mit virtuellen Methoden am effektivsten.

Fehlermeldung
Wenn ich list->push_back(..) entferne, compiliert es.

class BASE
{
public:
	typedef pair<string, function<int(int)> > FEntry;
	typedef vector<FEntry> FList;

	virtual FList* getFuncs() = 0;
};

class MOD : public BASE
{
public:
	virtual FList* getFuncs()
	{
		FList* list = new FList();

		/*
		 *   i = std::make_pair("foo", std::bind(&init::foo, this));
		 * ++i = std::make_pair("bar", std::bind(&init::bar, this));
		 * */

        // HIER
		list->push_back( (FEntry)make_pair( "mow", bind(&MOD::mow, this) ));

		//ENTRY("Sub", sub); // mittels define

		return list;
	}

	int mow(int in)
	{
		return in * 2;
	}

	int sub(int in)
	{
		return in - 100;
	}
};

int main()
{
    // noch leer
	return 0;
}

Hast du schonmal überlegt auf Funktoren umzusteigen, anstatt Funktionen zurückzugeben?

Virtuelle funktionen sind einen ganz kleinen tacken langsamer als normale nicht-virtuelle funktionen. Ich werde auch viele funktionen in den plugins aufrufen, sehr oft...

Du willst also dynamic binding ohne eine zusätzliche Indirektion? Sry aber das ist ganz einfach nicht möglich.

Sollte ich dann boost::bind(&MOD::mow, _1, this) aufrufen? Für zwei Parameter dann _1, _2 ?

Nein, boost::bind(&MOD::mow, this, _1 ).

Tachyon schrieb:

lk schrieb:

[...]Und virtuelle funktionen will ich auch nicht, da die etwas langsamer sind....

Langsamer als was? Als ein ähnlicher Mechanismus von Dir selbst gebastelt? Wohl kaum. Für Plugins braucht man wohldefinierte Interfaces. Und dafür bieten sich unter C++ Klassen mit rein virtuellen Funktionen an.

Ich will ja nicht direkt Plugins machen.

Virtuelle funktionen sind einen ganz kleinen tacken langsamer als normale nicht-virtuelle funktionen. Ich werde auch viele funktionen in den plugins aufrufen, sehr oft...

so what... Lies Dich mal in das Thema: "Premature Optimizing" ein, denn genau das machst Du gerade. Du versuchst ein etabiliertes, optimiertes System (virtuelle Funktion) durch etwas ähnliches zu ersetzen was unterm Strich eher langsamer als schneller sein wird. Abgesehen davon, selbst wenn der Aufruf einer virtuellen Funktion langsamer ist, so macht das vielleicht 0.000001% Deiner Rechnerperformance aus. Optimier lieber erstmal an anderen Stellen die auch eine meßbare Auswirkung auf die Performance haben.

Die Aussage dass virtuelle Funktionen langsam sind ist jedenfalls vollkommen Sinnlos.

so what... Lies Dich mal in das Thema: "Premature Optimizing" ein, denn genau das machst Du gerade. Du versuchst ein etabiliertes, optimiertes System (virtuelle Funktion) durch etwas ähnliches zu ersetzen was unterm Strich eher langsamer als schneller sein wird. Abgesehen davon, selbst wenn der Aufruf einer virtuellen Funktion langsamer ist, so macht das vielleicht 0.000001% Deiner Rechnerperformance aus. Optimier lieber erstmal an anderen Stellen die auch eine meßbare Auswirkung auf die Performance haben.

Ein anderes Problem wäre, dass ich dann 2 zusätzliche klassen für jede klasse machen müsste. Übrigens hab ichs gerade hingekriegt...

Ein schwacher Punkt wird wohl Baz::assign(..) sein...

Mein Code jetzt:
(in die main() funktion gucken )

class Foo
{
public:
    typedef function<int(int)> Func;
    typedef pair<string, Func > FEntry;
    typedef vector<FEntry> FList;

    //typedef int(Foo::* F)(int); // one static function
    //typedef vector< F > FL; // list of all of them

    virtual FList* getFuncs() = 0;
};

class Bar : public Foo
{
private:
    int data;

public:
    virtual FList* getFuncs()
    {
        FList* list = new FList();

        #define ENTRY(x,y) list->push_back(std::make_pair( string( x ) , boost::bind( &Bar:: y , this, _1 ) ));

        list->push_back( std::make_pair(string("mow"), boost::bind(&Bar::mow, this, _1) ) );
        list->push_back( std::make_pair(string("sub"), boost::bind(&Bar::sub, this, _1) ) );

        // hehehe :)
        ENTRY("set", set);
        ENTRY("get", get);

        /*
         *   i = std::make_pair("foo", std::bind(&init::foo, this));
         * ++i = std::make_pair("bar", std::bind(&init::bar, this));
         * */

        // list->push_back( (FEntry)make_pair( "mow", boost::bind(&Bar::mow, 435, this) ));

        //ENTRY("Sub", sub);

        return list;
    }

    int set(int val)
    {
        data = val;
        return val;
    }

    int get (int dummy)
    {
        return data;
    }

    int mow(int in)
    {
        return in * 2;
    }

    int sub(int in)
    {
        return in - 100;
    }
};

struct Baz
{
    typedef Foo::Func f;

    int assign(Foo* foo)
    {
        Foo::FList *list = foo->getFuncs();
        Foo::FEntry cur;

        //cout << "Baz::assign] list = " << list << endl;

        for (int i=0; i<list->size(); i++)
        {
            // switch mit strings o.O ?

            cur = list->at(i);

            //cout << "Baz::assign - for] cur.1=\"" << cur.first << " &cur.2=" << &cur.second << endl;

            if (!cur.first.compare("mow")) {
                mow = cur.second;
                continue;
            } else if (!cur.first.compare("sub")) {
                sub = cur.second;
                continue;
            } else if (!cur.first.compare("set")) {
                set = cur.second;
                continue;
            } else if (!cur.first.compare("get")) {
                get = cur.second;
                continue;
            }
            cout << "Baz::assign - for] Pointless function: " << cur.first << endl; // keine Übereinstimmung gefunden
        }
        return 0;
    }

    f mow;
    f sub;
    f set;
    f get;
};

int main()
{
    Foo *ptr = new Bar(); // hier würde eigentlich eine funktion aus der Dynamischen bibliothek
    // aufgerufen werden: make();

    /*
    Foo::FList *flist = ptr->getFuncs();
    Foo::FEntry e_mow = flist->at(1);
    Foo::Func mow = e_mow.second;

    Foo::Func set = flist->at(2).second;
    Foo::Func get = flist->at(3).second;

    cout << set(352) << endl;
    cout << get(0) << endl;
    */

    Baz *bar = new Baz(); // "pseudo klasse"

    bar->assign(ptr);

    bar->set(372);
    cout << bar->get(0) << endl;

    return 0;
}