Die bisherige Lösung sieht so aus:

typedef void (*pFunktion)(long);  // Definition des Typs

...
void Func0(long input)            
{
vMETAPANEL[0].TriggerToolbar0(input);
} 

void Func1(long input)            
{
vMETAPANEL[1].TriggerToolbar0(input);
} 

// ... usf  bis 100

pFunktion Function[100]; 

void InitFunctions()
{
Function[0] ) &Func0;
Function[1] ) &Func1;
// usw.
}

Man sieht: Func1 unterscheidet sich von Func0 nur dadurch, dass es eine andere Instanz einer in einem Vektor gespeocherten Klasse anspricht, also nur eine Variable hochzählt.

So wie ich das jetzt angelegt habe, funktioniert's - aber ist natürlich extrem umständlich. Gibt es da keine bessere Lösung?

Aber wofür machst du das überhaupt? Was tust du mit einem solchen Array?

void Func(int iIndex, long lInput)
{ vMETAPANEL[iIndex].TriggerToolbar0(lInput); };

Bei deinem Funktionsarray musst du ja auch über einen Indexzeiger zugreifen. Irgendwie versteh ich das Problem nicht.

Grüssli

Der Grund dafür liegt dartin, dass ich auf eine Event-Funktion aus einer Library zugreife,die mir nur diesen Typ erlaubt:

void Func(long lInput) // wobei der long Wert die Adresse der Funktion übernimt

Ich verstecke also den Index im Funktionsnamen - und um das halbwegs erträglich zu machen, schreibe ich dann den Array.

Der Hintergrund ist natürlich: Übergabe eines Methodenzeigers - aber wie man sieht, gerät mir der Mangel an Argmumenten einfach zum Problem.

Danke schön für die Anteilnahme, vieleicht doch jemand da, der meine Begriffsblockade auflöst.

Das habe ich leider gar nicht verstanden:
std::tr1::bind

Wie müsste ich das machen?

template<int iIndex>
void Func(long lInput)
{ vMETAPANEL[iIndex].TriggerToolbar0(lInput); };

// Verwendung:
funktion_zur_api_oder_was_auch_immer(&Func<0>);
funktion_zur_api_oder_was_auch_immer(&Func<3>);

Es müsste aber zur Compilezeit bekannt sein, was für eine Nummer, wann aufgerufen wird.

Ansonsten kannst du vielleicht so die Sache ein wenig schneller erstellen lassen:

void InitFunctions()
{
    Function[0] = &Func<0>;
    Function[1] = &Func<1>;
    // usw.
}

Aber wie gesagt, verstanden habe ich deine Problemstellung nicht und von mir aus gesehen ist hier irgendwo ein Designfehler.

Grüssli

Aber wie gesagt, verstanden habe ich deine Problemstellung nicht und von mir aus gesehen ist hier irgendwo ein Designfehler.

Ist es, aber in der Bibliothek

@Standardkundige, ist sowas konform?

void tolle_funktion_die_aufruft (int Index)
{
    struct Bla
    {
        static void func (long Input)
        {
            vMETAPANEL[Index].TriggerToolbar0(Input);
        }
    }

    gangsta_bibliotheks_funktion (&Bla::func);
}

Wobei das wohl spätestens dann ziemlich in die Hose geht, wenn gangsta_bibliotheks_funktion den Zeiger speichert ...

Hmm, Percy, ich glaub' dir bleibt tatsächlich kaum was anderes übrig (bind würde nur helfen, wenn beliebige Funktionsobjekte erlaubt wären). Um dir die Arbeit etwas zu vereinfachen und den Code zu verkürzen, könntest du ihn mit Boost.Preprocessor oder mit tollen Metaprogrammen erzeugen lassen.

template <unsigned I>
struct meta_function_init
{
    static void func (long Input)
    {
        vMETAPANEL[I].TriggerToolbar0(Input);
    }

    meta_function_init (std::vector<function>& array)
    {
        meta_function_init<I - 1> blubb (array);
        array.push_back (&meta_function_init::func);
    }
}

template <>
struct meta_function_init<0>
{
    static void func (long Input)
    {
        vMETAPANEL[0].TriggerToolbar0(Input);
    }

    meta_function_init (std::vector<function>& array)
    {
        array.push_back (&meta_function_init::func);
    }
};

Und dann

void InitFunctions ()
{
    meta_function_init<TOLLE_GROßE_KONSTANTE> initer (array);
}

/edit: Danke Dravere

Grüssli

Der Grund dafür liegt dartin, dass ich auf eine Event-Funktion aus einer Library zugreife,die mir nur diesen Typ erlaubt:

void Func(long lInput) // wobei der long Wert die Adresse der Funktion übernimt

Bedank dich bei den Idioten, die diese API entworfen haben. Da man keine zusätzlichen Daten übergeben kann hast du ganz einfach verloren.

Wenn du wissen willst wie sowas aussieht guck dir die Implementierung der Window-Klassen in der ATL an, da werden solche dynamisch erzeugten Thunks verwendet.

die idee ist gut. Wenn man aber codesnippets prozessorspezifisch compiled, die dann, je nach art kombiniert, in den speicher gelegt werden, dürfte das auch portierbar sein. Man müsste sich dann bloß noch n kleenes köpfchen für den datenaustausch zwischen den snippets machen. (Gibts da keine lib für??)
Gibt es aber i.A. keine javascript ähnliche func. eval() für c/c++ ??

grüüüße