Print-Adresse der virtuellen member-Funktion

Ich versuche, drucken Sie die Adresse einer virtuellen member-Funktion.
Wenn ich weiß, welcher Klasse Sie implementiert die Funktion kann ich schreiben:

print("address: %p", &A::func);

Aber ich wollen, so etwas zu tun:

A *b = new B();

printf("address: %p", &b->func); 
printf("address: %p", &b->A::func);

Allerdings nicht kompilieren. Ist es möglich, so etwas zu tun, vielleicht suchen die Adresse der vtable zur Laufzeit?

InformationsquelleAutor hidayat | 2010-06-18

  1. 13

    Derzeit gibt es keine standard-Weg, dies zu tun, in C++, obwohl die Informationen verfügbar sein müssen, irgendwo. Wie sonst könnte das Programm die Funktion aufrufen? Jedoch, GCC bietet eine Erweiterung, die es uns erlaubt, um die Adresse eines virtuellen Funktion:

    void (A::*mfp)() = &A::func;
printf("address: %p", (void*)(b->*mfp));

    ...vorausgesetzt die member-Funktion hat den Prototyp void func().
    Dies kann Recht nützlich sein, wenn Sie wollen, um den cache der Adresse eines virtuellen Funktion zu nutzen oder es im generierten code. GCC warnt Sie über dieses Konstrukt, es sei denn, Sie geben -Wno-pmf-conversions. Es ist unwahrscheinlich, dass es funktioniert mit jedem anderen compiler.

    InformationsquelleAutor Lukas W

  2. 6

    Zeiger auf member-Funktionen sind nicht immer einfachen Speicher-Adressen. Siehe die Tabelle in dieser Artikel zeigt die Größen der member-Funktion-Zeiger auf verschiedene Compiler - einige gehen bis zu 20 bytes.

    Als der Artikel skizziert eine member-Funktion-Zeiger ist tatsächlich ein blob von der Implementierung definierte Daten zur Lösung eines Anrufs über den Zeiger. Sie können speichern und Sie zu rufen, OK, aber wenn Sie wollen, zu drucken, was Sie drucken? Am besten behandeln Sie es als eine Sequenz von bytes, und seine Länge über sizeof.

    Doch das problem bleibt: wie identifizieren Sie die Funktion, aufgerufen durch eine virtual nennen 🙂 ?
    Das war nicht Teil der Frage war es? Aber ich würde die Antwort durch den Aufruf' 🙂

    InformationsquelleAutor AshleysBrain

  3. 2

    Habe ich einen Weg gefunden, dies zu tun mit einem disassembler (https://github.com/vmt/udis86). Die Schritte sind:

    1. Einen Zeiger auf die virtuelle Funktion über den normalen C++ - code

    2. Zerlegen die jmp Instruktion an dieser Adresse

    3. Parse die real-Adresse aus den zerlegten string

    Hier ist, wie ich es gemacht habe:

    //First get the raw pointer to the virtual function
auto myVirtualFuncPtr = &MyClass::myFunc;
void* myVirtualFuncPtrRaw = (void*&)myVirtualFuncPtr;

//Resolve the real function!
void* myFuncPtr = resolveVirtualFunctionAddress(myVirtualFuncPtrRaw);

...

static void* resolveVirtualFunctionAddress(void* address)
{
    const int jumpInstructionSize = 5;

    static ud_t ud_obj;
    ud_init(&ud_obj);
    ud_set_mode(&ud_obj, sizeof(void*) * 8);
    ud_set_syntax(&ud_obj, UD_SYN_INTEL);
    ud_set_pc(&ud_obj, (uint64_t)address);
    ud_set_input_buffer(&ud_obj, (unsigned uint8_t*)address, jumpInstructionSize);

    std::string jmpInstruction = "";

    if (ud_disassemble(&ud_obj))
    {
        jmpInstruction += ud_insn_asm(&ud_obj);
    }

    //TODO: Implement startsWith and leftTrim yourself
    if (startsWith(jmpInstruction, "jmp "))
    {
        std::string jumpAddressStr = leftTrim(jmpInstruction, "jmp ");
        return hexToPointer(jumpAddressStr);
    }

    //If the jmp instruction was not found, then we just return the original address
    return address;
}

static void* hexToPointer(std::string hexString)
{
    void* address;
    std::stringstream ss;

    ss << std::hex << hexString;
    ss >> address;

    return address;
}

    InformationsquelleAutor Zachary Canann

  4. 1

    Macht nicht viel Sinn für mich. Wenn Sie eine normale Funktion:

    void f( int n ) {
}

    dann können Sie seine Adresse:

    f

    aber Sie können nicht die Adresse einer Funktion nennen, das ist, was Sie scheinen zu wollen, zu tun.

    Das ist, was ich dachte, sagte ich. Wie auch immer, ich glaube nicht, dass dies möglich ist.

    InformationsquelleAutor

  5. 1

    Was ich sagen kann, in der standard, die einzige Zeit, die Sie bekommen, dynamische Bindung ist, während eine virtuelle Funktion nennen. Und sobald Sie angerufen haben, eine Funktion, die Sie ausführen, werden die Anweisungen innerhalb der Funktion (d.h., Sie können nicht "auf halbem Wege stehenbleiben" in den Anruf bekommen und die Adresse.)

    Ich denke, es ist unmöglich.

    Ich nehme an, es ist unmöglich tragbar, aber zu wissen, die Umsetzung sollte es möglich sein, überprüfen Sie den virtuellen Tisch eines Objekts zur Laufzeit.

    InformationsquelleAutor GManNickG

Schreibe einen Kommentar