C++ - Funktionszeiger auf eine nicht statische Elementfunktion einer beliebigen Klassenart

Question

Ich habe eine Reihe von Beispielen gesehen, wie man einen Funktionszeiger auf ein C++ - Klasse nicht-statisches Element einer spezifischen-Klasse setzt. Allerdings würde ich für solche Zeiger verwenden, die für jede Typklasse funktionieren würden. Um die Idee zu demonstrieren, schrieb ich ein Pseudo-Beispiel:

class A 
{ 
    public: 
    A(){} //constructor  
    void callMe() { /* do something */ } 
}; 

class B 
{ 
    public: 
    B(){} //constructor  
    void callMe() { /* do something */ } 
}; 


main() 
{ 
    A aa; 
    B bb; 

    //pseudo part: 
    generic_method_pointer_type p; //how to define the type of p? 

    p=HOWTO;//set pointer p to point to A::callMe. How to do? 

    p(aa); //A::callMe on instance aa gets called 

    p=HOWTO;//set pointer p to point to B::callMe. How to do? 

    p(bb); //B::callMe on instance bb gets called 
} 

Sieht dies möglich?

Ich weiß, C++ 11 hat neue Tricks wie Std :: Funktion dafür. Ich habe einige Experimente an der std :: function durchgeführt und fand es zu langsam für eine Echtzeit-App, die auf einem kleinen Mikrocontroller läuft. Aus diesem Grund würde ich direkt hart codierte Zeiger bevorzugen, die minimalen Overhead verursachen würden.

Vielen Dank für Ihren Hinweis!

Answer 1

Gefunden eine perfekt funktionierende Lösung von mbed Projekt Quellcodes (ihre Funktionszeiger-Klasse):

• https://developer.mbed.org/cookbook/FunctionPointer
• https://github.com/Seeed-Studio/mbed_ble/blob/master/mbed-src/api/FunctionPointer.h
• https://github.com/Seeed-Studio/mbed_ble/blob/master/mbed-src/common/FunctionPointer.cpp

Arbeitsbeispiel:

A foo; 
FunctionPointer cb; 
cb.attach(&foo,&A::callMe); 
for(i=0;i<100000000;i++) //callback overhead test 
    cb.call(); 

Der Code innerhalb von FunctionPointer ist für mich nicht sehr offensichtlich, wie es funktioniert. Es memcpy einige Daten usw. Irgendwelche Ideen, wenn es vereinfacht werden könnte & schneller gemacht? Es bewirkt, dass immer noch deutlich mehr Aufwand im Vergleich zu einem Fall, in dem Klassentyp festgelegt ist, wie zum Beispiel:

A foo; 
typedef void (A::*MethodPtr)(); 
MethodPtr method = &A::callMe; 
Foo *obj = &foo; 
for(i=0;i<100000000;i++) //callback overhead test 
    (obj->*method)(); 

Das obige Verfahren ist etwa 4x schneller im Vergleich zu Funktionszeigern Methode, wenn callme nur asm enthält („nop“). Einige Benchmarks für x86 & GCC:

• direkten Aufruf 205 ms
• die obige Funktionszeiger Beispiel 258 ms
• Funktionszeiger Beispiel 1049 ms
• std :: function 3951 ms

Alle Optimierungsideen werden sehr geschätzt!