Bisher kann ich ohne Probleme die Adressen der folgenden Adressen auslesen:

• CTest::FunktionA
• CTest::FunktionB
• CTest::FunktionC (nur MSVC++)

Gibt es einen Weg, die Adressen von folgenden Funktionen zu erhalten?:

• CTest::CTest
• CTest::~CTest
• CTest::FunktionC
• CTest::FunktionD ()
• CTest::FunktionD (int)

Gruß

Destruktor und Konstruktor geht nicht (gibt auch keinen Sinn). Alle anderen einfach mit dem Addressoperator &.

Gruß

Konstruktor und Destruktor hätte ich aber gerne, sind auch nur Funktionen
Und es ist keineswegs möglich die Adresse der Funktionen "FunktionC" und "FunktionD" mit dem Adressoperator zu erhalten.

z.B.

&CTest::FunktionD

Hier weiß der Compiler nicht, welche Überladung von "FunktionD" gemeint ist.

A use of an overloaded function name without arguments is resolved in certain contexts to a function, a
pointer to function or a pointer to member function for a specific function from the overload set. A function
template name is considered to name a set of overloaded functions in such contexts. The function
selected is the one whose type matches the target type required in the context. The target can be
— an object or reference being initialized (8.5, 8.5.3),
— the left side of an assignment (5.17),
— a parameter of a function (5.2.2),
— a parameter of a user-defined operator (13.5),
— the return value of a function, operator function, or conversion (6.6.3),
— an explicit type conversion (5.2.3, 5.2.9, 5.4), or
— a non-type template-parameter (14.3.2).
The overloaded function name can be preceded by the & operator. An overloaded function name shall not
be used without arguments in contexts other than those listed. [Note: any redundant set of parentheses surrounding
the overloaded function name is ignored (5.1). ]

Beispiel (ist bei Methoden das selbe):

void foo() { cout << "foo()"; }          // #1
void foo(int) { cout << "foo(int)"; } ;  // #2

typedef void (*funcptr1)();    // Typ eines Pointer auf #1
typedef void (*funcptr2)(int); // Typ eines Pointer auf #2

// no. 1
funcptr1 a = &foo; // ok!

// no. 2
void iNeedTypeOne(funcptr1 ptr);
iNeedTypeOne(&foo); // ok, selbes mit konstruktoren, operatoren!

// no. 3
static_cast<funcptr1>(&foo); // ok!

// no. 4
funcptr1 iReturnTypeOne() {
    return &foo; // ok!
}

Gruß

Folgende Probleme bleiben:

• Adressen von Konstruktor und Destruktor

error C2277: 'CTest::{ctor}' : cannot take address of this member function
error C2277: 'CTest::~CTest' : cannot take address of this member function

• Adressen von virtuellen Funktionen
• Eine Funktion, Makro, Inline-Assembler (MSVC++), mit der man jede Funktionsadresse in z.B. void* speichern kann (z.B. GetAddress (Beliebige::Funktion))

Standard 12.1.12 schrieb:

The address of a constructor shall not be taken.

Standard 12.4.2 schrieb:

The address of a destructor shall not be taken.

- Virtuelle Methoden: Wo ist das Problem?

struct Base // base class
{
    virtual void func() { cout << "Base::func() \n"; }
};

struct Derived : public Base // derived class
{
    void func() { cout << "Derived::func() \n"; }
};

typedef void (Base::*memptr)();
memptr ptr = &Base::func;

Base* obj = new Derived;
(obj->*ptr)();
delete obj;

- Zu dem "Zabermakro": Im Grunde operator &, die Beschränkung bei überladenen Funktion kannst du nicht umgehen, der Compiler muss ja irgendwie wissen welche Funktion du meinst

Gruß

Mit GetAddress meine ich folgendes:

GetAddress (&CTest::CTest);
GetAddress (&CTest::~CTest);
GetAddress (&CTest::FunktionA);
GetAddress (&CTest::FunktionB);
GetAddress (&CTest::FunktionC);
GetAddress ((void (CTest::*)())&CTest::FunktionD);
GetAddress ((void (CTest::*)(int))&CTest::FunktionD);

Die tatsächliche Adresse der virtuellen Methode zu bekommen macht doch gar keinen Sinn, dann kannst du gleich das virtual weg lassen.

Konstruktor- und Destruktoradresse bekommst du nicht. Das geht nicht. Auf jeden Fall nicht laut dem C++-Standard, da kannst du machen was du willst. Das gibt auch gar keinen Sinn zu was brauchst du die?

Hier hast du deine Zauberfunktion:

template<typename T>T getAddress(T t) { return t; } //scnr

PS: Bin nun im Bett und das Forum ist mal wieder langsamer als der Doppelklick meiner Mutter

Gruß

Ich glaube du versucht gerade die Sprache zu vergewaltigen um deine Designfehler auszubügeln.

Ich suche eine Funktion/Macro, die die Adressen beliebige Funktionen und Methoden zurückgibt. Bisher mache ich das über ein Makro mit Assembler, da ich dann nur z.B. GetAddress (Klasse::Methode) machen muss. Leider kann ich auf die Art nicht die Adresse von überladenen Funktionen auslesen, da z.B. folgendes nicht möglich ist:

__asm mov eax, (void (CTest::*)())&CTest::FunktionD

@FireFlow: Deine getAddress-Funktion ist nichts anderes als die identische Funktion

__asm mov eax, (void (CTest::*)())&CTest::FunktionD

Diese Zeile nicht sinnvoll. Ein Pointer-To-Member belegt üblicherweise 12-16 Bytes und kann somit sehr schlecht ins EAX-Register passen.

Auf Methoden/Funktionen eines Programms, welches du nicht kennst, kannst du nicht (sicher) zugreifen. Dazu fehlen dir Informationen. Z.B. welche Aufrufkonvention verwendet wird. Oder mit welchem Compiler das Programm übersetzt wurde und wie z.B. vtables im Speicher organisiert sind.

Im übrigen, &Klasse::Methode sollte niemals den virtuellen Mechanismus bemühen (wie auch - vtables existieren zwar pro Klasse, sind aber objektgebunden) sondern immer einen Zeiger auf die Methode der bezeichneten Klasse geben.

Neku schrieb:

__asm mov eax, (void (CTest::*)())&CTest::FunktionD

Diese Zeile nicht sinnvoll. Ein Pointer-To-Member belegt üblicherweise 12-16 Bytes und kann somit sehr schlecht ins EAX-Register passen.

Wieso 12-16 Byte?
Mein Problem ist eher, dass der Cast-Operator hier nicht genutzt werden kann, und ich somit nicht bestimmen kann, welche der überladenen Methoden verwendet wird.

7H3 N4C3R schrieb:

Auf Methoden/Funktionen eines Programms, welches du nicht kennst, kannst du nicht (sicher) zugreifen. Dazu fehlen dir Informationen. Z.B. welche Aufrufkonvention verwendet wird. Oder mit welchem Compiler das Programm übersetzt wurde und wie z.B. vtables im Speicher organisiert sind.

Das Programm kenne ich schon, nur den Quellcode nicht.

7H3 N4C3R schrieb:

Im übrigen, &Klasse::Methode sollte niemals den virtuellen Mechanismus bemühen (wie auch - vtables existieren zwar pro Klasse, sind aber objektgebunden) sondern immer einen Zeiger auf die Methode der bezeichneten Klasse geben.

Ich möchte nur die Adresse der Methode, ob sie virtuell ist spielt dabei keine Rolle - der vtable ist in meinem Fall unwichtig.

Lies bitte erstmal den ganzen Thread. Ich habe nie davon geschrieben, dass ich die Methode aufrufen möchte...

Was willst du sonst mit den Funktionen machen?

ich habe das gefühl, er weiß allgemein nicht von was er redet!
er hat hier in einem thread auch schon gesagt, das es egal ist wo ein zeiger hinzeigt...

ich denk langsam, er isn troll...

Neku schrieb:

Lies bitte erstmal den ganzen Thread. Ich habe nie davon geschrieben, dass ich die Methode aufrufen möchte...

lies du dir nochmal paar tutorials durch...oben rechts in der ecke findest du einen link, da gibts viele gute anfängertutorials...

Wieso 12-16 Byte?
Mein Problem ist eher, dass der Cast-Operator hier nicht genutzt werden kann, und ich somit nicht bestimmen kann, welche der überladenen Methoden verwendet wird.

Fang doch mal mit diesem Artikel hier an:
http://www.codeproject.com/cpp/FastDelegate.asp

Und lies insbesondere den Abschnitt "Member Function Pointers - why are they so complex?"

Neku schrieb:

Lies bitte erstmal den ganzen Thread. Ich habe nie davon geschrieben, dass ich die Methode aufrufen möchte...

Was willst du sonst mit den Funktionen machen?

Da ich zur Laufzeit per DLL in einem Programm Methoden durch eigene überschreibe brauche ich die Adresse, damit ich einen Sprung in den Speicher schreiben kann, wo sich die Originalmethode befindet. Da ich aber versuche, Funktionen, Methoden und Objekte möglichst genau zu rekonstruieren habe ich auch virtuelle Methoden.

Falls mal noch jemand wissen muss, wie das möglich ist:
Den Quellcode mit dem Argument "-Wno-pmf-conversions" kompilieren, sodass man problemlos &Klasse::VirtuelleMethode nach void* casten kann.

Wofür ich noch immer keine Lösung gefunden habe sind sind Konstruktoren und Destruktoren

Grüße,
Marc