Wenn ich also eine nicht virtuelle Klasse nehme, davon ein Objekt erzeuge und versuche einen Funktionszeiger auf eine Methode dieses Objekts zu richten, dann habe ich ernsthafte Probleme - es klappt nicht! Ich versuche schon seit 2 Stunden rum und es will nicht. Funktionszeiger auf normale Funktionen sind überhaupt kein Problem. Sobald ich mit Objekten arbeite klappt´s nicht mehr. Das Problem ist, daß ich es nicht schaffe die Adresse einer Objektmethode rauszureferenzieren. Gibt es da einen Trick?

Wie hast du denn die Klasse bzw. die Methode definiert? Ist die Methode public oder private?

Wie hast du denn bisher versucht, die Adresse zu referenzieren?

Einen Zeiger auf ein Klassenelement bekommt man soweit ich weiss durch:

Objektname->Methodename

Schon probiert?

Ich habe schon alles durchprobiert (public, private, protected) der -> Operator ist das Dereferenzieren von Zeigern=Inhalt der Variable. Was ich jedoch bräuchte wäre die Adresse der Funktion. Diese läßt sich aber selbst innerhalb des Objekts nicht referenzieren. Ein Nachschlagen im Stroutrup & noch ein paar anderen Büchern wurde nicht mit einem Wort erwähnt, daß das möglich wäre. Deshalb gehe ich davon aus, daß es einfach nicht geht. Es wäre nur möglich, wenn das Objekt ein eigenständiger Datentyp ist (jedenfalls nach der Fehlermeldung)! Da das bei Objekten wohl nicht der Fall ist ist das unmöglich. Damit will man offensichtlich vor Mißbrauch schützen.

Hilft Dir das weiter?

class A {

public:

	int a( char c ) {

		return 0;

	}

};


class B {

public:

	A m_A;

	int b() {

		int( A::*methodptr)(char) = m_A.a;

		return (m_A.*methodptr)( 'x' );

	}

};

[/CODE]

Super Klotzkopp!!!

Ich wußte, daß man das doch irgendwie hinbekommen sollte. Allerdings das was ich beabsichtigt habe funktioniert immer noch nicht. Das man Funktionszeigern von Klassen auf Members haben kann ist allerdings schon mal was - was mir übrigens unbekannt war - davon hatte ich auch noch nie etwas gehört. Allerdings wenn man logisch nachdenkt ist es aufgrund der Klassenkonzeption wohl die einzige erlaubte Variante.

Was ich noch vergeblich probiert hatte war innerhalb einer Klasse einen Funktionszeiger auf eine Methode derselben Klasse zu erzeugen: Das ging auch nicht. Ich habe danach halt irgendwo im Programm von einer Klasse ein Objekt erzeugt und versucht mit aller Gewalt dann mit einer Objektmethode einen Funktionszeiger zu erzeugen - und das ist offensichtlich nicht möglich.

Was mich noch etwas verwirrt ist, daß ein Funktionszeiger nur dann initialisierbar ist, wenn er in einer Methode versteckt ist. Warum nur dann? Gibt es da eine logische Erklärung für?

Interessant wäre es noch zu wissen, ob man Funktionszeiger als Returnwert weiterreichen kann, dann wäre meine Frage auch komplett gelöst. Schau ich mir an, wenn es mir wieder besser geht (lieg mit Grippe flach).

Vielleicht noch eins: Wo hast Du das denn gefunden? In meinen Büchern war eine solche Möglichkeit NIRGENDS erwähnt.

Um Funktionszeiger zurückzugeben, würde ich einen typedef empfehlen, ohne würde das wohl ziemlich wild aussehen.

Also das hier funktioniert:

class A;	// fwd decl


typedef int (A::* pfoo_t)(char);


class A 

{

public:

    int foo( char c ) { return 0; }

    pfoo_t getfoo() { return foo; }

};


int main(int argc, char* argv[])

{

    A a;

    pfoo_t p = a.getfoo();

    return (a.*p)( 'x' );

}

[/CODE]


Weitere Info z.B. in der MSKB, Q94579.

Auch die MSDN hat Infos über die Operatoren .* und ->*.

Danke!

Du bist echt genial (würde mich auch interessieren wie lange Du schon lernst - oder ob Du überhaupt noch lernst).

Typedefs sind immer eine feine Sache bei Templates und Funktionszeigern - find ich auch.

Vielleicht noch eine Kleinigkeit:

Das foo als Beispielsvariable ist mir klar, aber gerade bei Referenzen wird gerne als Name in Beispielcode als RHS bezeichnet - bedeutet das nicht irgendwas, abgekürzt?

Ich hatte meine Abschlussprüfung im Sommer 2001. Die zweigeteilte, falls sich noch jemand erinnert

Das 'RHS' kenne ich hauptsächlich von überladenen Operatoren. Ich nehme an, das soll für "Right Hand Side", also den Operanden auf der rechten Seite stehen.

vielleicht ist das ja auch interessant

//: C11:PmemFunDefinition.cpp

class Simple2 {

public:

int f(float) const { return 1; }

};

int (Simple2::*fp)(float) const;

int (Simple2::*fp2)(float) const = &Simple2::f;

int main() {

fp = &Simple2::f;

} ///:~

In the definition for fp2 you can see that a pointer to member

function can also be initialized when it is created, or at any other

time. Unlike non-member functions, the & is not optional when

taking the address of a member function. However, you can give

the function identifier without an argument list, because overload

resolution can be determined by the type of the pointer to member.

weiteres Beispiel:

//: C11:PointerToMemberFunction2.cpp

#include <iostream>

using namespace std;

class Widget {

void f(int) const { cout << "Widget::f()\n"; }

void g(int) const { cout << "Widget::g()\n"; }

void h(int) const { cout << "Widget::h()\n"; }

void i(int) const { cout << "Widget::i()\n"; }

enum { cnt = 4 };

void (Widget::*fptr[cnt])(int) const;

public:

Widget() {

fptr[0] = &Widget::f; // Full spec required

fptr[1] = &Widget::g;

fptr[2] = &Widget::h;

fptr[3] = &Widget::i;

}

void select(int i, int j) {

if(i < 0 || i >= cnt) return;

(this->*fptr)(j);

}

int count() { return cnt; }

};

int main() {

Widget w;

for(int i = 0; i < w.count(); i++)

w.select(i, 47);

} ///:~

Similarly, when the pointer-to-member is dereferenced, it seems

like

(this->*fptr)(j);

is also over-specified; this looks redundant. Again, the syntax

requires that a pointer-to-member always be bound to an object

when it is dereferenced.

die Beispiele sind aus dem Buch Thinking in C++ von Bruce Eckel. Kann man sich als pdf bei http://www.bruceeckel.com laden.