Methode-Call: this-Pointer

Hi,

ich hab mehrere Klassen, die alle eine Methode gemeinsam haben. In einem zweiten Thread möchte ich jetzt einen void-Pointer übergeben, welcher immer der this-Pointer einer solchen Klasse ist.

Kann ich jetzt ohne wieder zu casten, abhängig vom this-pointer immer die richtige Klassenmethode aufrufen?

class Test1
{
   void Testmethode();
};

class Test2
{
   void Testmethode();
};

class Test3
{
   void Test(void *ptr);
};

/* ******* aufruf der funktion ******** */
void Test2::CallFunc()
{
   Test3 work;
   work.Test(this);
}

/* ******** funktion selbst ************ */
void Test3::Test(void *ptr)
{
  ptr->Testmethode(); 

}

Geht der letzte Step auch ohne Casten?? Momentan zeigt mir das visualstudio an, dass es leider nicht geht

Gruß
Damian

class Test3
{
   template<typename T> void Test(T *obj); // besser: void Test(T &obj);
};

template<typename T>
Test3::Test(T *obj) // bzw. void Test(T &obj)
{
  obj->Testmethode(); // bzw. obj.Testmethode();
}

Mögliche Verbesserungen noch einmal als Liste:

Reference (&-Symbol) anstatt Pointer (*-Symbol)
ev. Testmethode als const deklarieren und einen Verweis auf const annehmen
Vererbung:

class testmethod { virtual void Testmethode() const =0; };
class Test1 : testmethod { virtual void Testmethode() const; };
class Test2 : testmethod { virtual void Testmethode() const; };
// Der Aufruf geht dann einfach:
void Test3::Test(const testmethod &obj) {
  obj->Testmethode();
}

Visual Studio in den Müll werfen und eine gescheite IDE verwenden.

Visual Studio ist für Windows eine der gescheitesten IDEs.

Michael E.

templati schrieb:

class testmethod { virtual void Testmethode() const =0; };
class Test1 : testmethod { virtual void Testmethode() const; };
class Test2 : testmethod { virtual void Testmethode() const; };
// Der Aufruf geht dann einfach:
void Test3::Test(const testmethod &obj) {
  obj->Testmethode();
}

Du wolltest sicher öffentlich vererben, nicht wahr?

Ja, stimmt.

templati schrieb:

Visual Studio in den Müll werfen und eine gescheite IDE verwenden.

Da musst ich schmunzeln

#include <iostream>

/*
	Also "void" enthält keine Typinformation, d.h. du musst natürlich casten.
	Da deine Klassen nichts miteinander zu tun haben, müsstest du immer genau zu dem entsprechenden Typ casten ... irgendwie sinnlos.
	Da deine Klassen aber gleiche Methoden aufweisen, spricht doch alles dafür, dass du ein Interface verwendest.
*/
class Interface
{
	public:
		virtual void Testmethode() = 0;
}; 

class Test1 : public Interface
{
	public:
		virtual void Testmethode()
		{
			std::cout << "Test1";
		}
};

class Test2 : public Interface
{
	public:
		void Testmethode()
		{
			std::cout << "Test2";
		}
};

void callFunc(Interface& r)
{
	r.Testmethode();
}

int main()
{
	Test1 test1;
	Test2 test2;

	callFunc(test1);
	callFunc(test2);

	return 0;
}

/*
	Wichtig für dein Vorhaben ist, dass die Klassen (zumindest die Basisklasse "Interface") polymorph ist.
	Wäre dies nicht der Fall, würde nicht der Datentyp des Objekts entscheiden, welche Funktion nun aufgerufen wird, sondern der Datentyp der Referenz/Zeiger.

	Eine Klasse ist polymorph, wenn min.1 Methode virtual ist.
	Ist die Basisklasse polymorph, dann ist es die abgeleitete Klasse automatisch polymorph.
*/

mfg dweb