Zum Inhalt springen

Empfohlene Beiträge

Geschrieben

hallo ich habe eine methode in meiner datenhaltungsklasse, die den paramter einer callbackfunktion bekommen soll.

in meiner anderen klasse, die diese methode aufrufen soll erstell ich den

funktionspointer

//funktionspointer erstellen

void (CErweiterungSnapShotDlg::*pfunction)(CString strProzess, CString strWert);

// jetzt zeigt pfunction auf CallbackFunction

pfunction = &CErweiterungSnapShotDlg::CallbackFunction;

nun will ich die methode der datenhaltungsklasse aufrufen

und den funktionspointer übergeben

mein problem ist, welchen datentyp muss ich denn in die methode reinschreiben für den funktionspointer, es soll allgemein gehalten werden...

also egal in welcher klasse diese methode aufgerufen wird, es kann immer ein beliebiger funktionspointer mitgegeben werden....

bitte, kann mir jemand helfen?

Geschrieben
Original geschrieben von Leana

mein problem ist, welchen datentyp muss ich denn in die methode reinschreiben für den funktionspointer, es soll allgemein gehalten werden...

Der Typ des Zeigers pfunction ist

void(CErweiterungsSnapShotDlg::*)(CString,CString)

also egal in welcher klasse diese methode aufgerufen wird, es kann immer ein beliebiger funktionspointer mitgegeben werden....
Falls du mit "beliebig" Zeiger auf Funktionen anderer Klassen oder mit anderer Signatur meinst: Das geht nicht. Du kannst an eine solche Funktion nur Zeiger auf Memberfunktionen von CErweiterungsSnapShotDlg übergeben, die void zurückgeben und zwei CString-Parameter haben. Du kannst eine solche Funktion über den Zeiger auch nur aufrufen, wenn du eine Instanz von CErweiterungsSnapShotDlg hast.
Geschrieben

das muss schon irgendwie gehen, aber wie?

templates vielleicht!

kann mir jemand helfen!

schließlich sollen ja die schnittstellen allgemein gehalten werden und nicht nur von diesem einem dialog

Geschrieben

Du könntest etwas in der Art machen:

class Test
{
public:
template <typename returntype, class C, typename Param1, typename Param2>
void foo( returntype(C::*funcp)(Param1,Param2) )
{
C x;
Param1 p1;
Param2 p2;
(x.*funcp)( p1, p2 );
}
};

class Callee
{
public:
void bar( int x, double y )
{
// irgendwas
}
};

int main()
{
Test t;
t.foo( &Callee::bar );
}[/CODE]

Geschrieben

ja, genau, dass sieht schon viel besser aus!

danke

kannst du mir nur kurz erleutern, da wo du Param 1 und param 1 hast

kann ich ja auch z.b. CString oder int oder so reinschreiben oder, wenn das fest definiert sein soll?

Geschrieben

Alles, was nicht variabel ist, kannst du aus der Templatedeklaration rausnehmen und fest in den Funktionskopf reinschreiben:

template <class C>
void foo( void(C::*funcp)(CString,int) )[/CODE]

Hier sind Rückgabetyp und Argumenttypen festgelegt, nur die Klasse nicht.

Geschrieben

ok ich hab das jetzt umgesetzt, mal schauen ob es geht.

kannst du mir aber bitte erklären warum ich fehler bekomme, wenn es outline ist?

und es bei inline das übersetzen funktioniert

Geschrieben

jetzt bekomm ich ständig linkerfehler

keine ahnung was falsch ist

kannst du nochmal drüber gucken

in der klasse steht

//öffentliche methoden

public:

template <typename returntype, class C>

void GetActualProcInformation(CString strProzess, int iInfoArt, returntype(C::*funcp)(CString,CString) )

{

C x;

int iStelle = FindPlace(strProzess);

CString strBack;

switch(iInfoArt)

{

case CPU_AUSLASTUNG:

strBack = m_ProzessArray[iStelle].GetWert();

break;

case VERGANGENE_ZEIT:

strBack = m_ProzessArray[iStelle].GetTime();

break;

case HANDLE_PROZESS:

strBack = m_ProzessArray[iStelle].GetHandleCount();

break;

case P_ID:

strBack = m_ProzessArray[iStelle].GetProzessID();

break;

case THREAD_HANDLE:

HANDLE = m_ProzessArray[iStelle].GetThreadHandle();

//strBack

break;

default:

break;

}

x.*funcp (strProzess, strBack);

}

mein aufruf in der anderen klasse:

//funktionspointer erstellen

void (CErweiterungSnapShotDlg::*pfunction)(CString strProzess, CString strWert);

// jetzt zeigt pfunction auf CallbackFunction

pfunction = &CErweiterungSnapShotDlg::CallbackFunction;

CString strProc = m_ListProzesse.GetItemText(0,0);

m_System.GetActualProcInformation(strProc, 1, pfunction);

wo liegt der fehler

Geschrieben
Original geschrieben von Leana

wo liegt der fehler

Wie lautet denn die Fehlermeldung?

Nachtrag: Ich kann's mir denken...

Die Definition der Templatefunktion muss in jeder Übersetzungseinheit, die sie verwendet, zur Verfügung stehen. Da einige Compiler mit dem Schlüsselwort export bei Templates nicht zurechtkommen, ist es am einfachsten, wenn du die Funktionsdefinition in die Headerdatei setzt.

Geschrieben
Original geschrieben von Leana

er kann nicht linken

Das hat schon seinen Grund, wenn ich nach dem genauen Wortlaut der Fehlermeldung frage, weil die Hinweise für die Fehlerursache liefern kann. Oder lautet die Meldung wirklich genau so? Kann ich mir nicht vorstellen. ;)
Geschrieben

jetzt hab ich es doch geschafft das er sich übersetzen wollte...

also ich guck mal ob es geht, ich versteh diesen compiler echt net

kannst mir das mit dem outline, inline erklären

Geschrieben

och mann ich dreh gleich durch.... :)

bei dem gibt es ne fehlermeldung

x.*funcp(strProzess, strBack);

fehlermeldung:

rror C2064: term does not evaluate to a function

d:\steffi\systemabfragentest\erweiterungsnapshot\erweiterungsnapshotdlg.cpp(1161) : see reference to function template instantiation 'void __thiscall CSystemInfo::GetActualProcInformation(class CString,int,void (__thiscall CErweiterungSnapSh

otDlg::*)(class CString,class CString))' being compiled

Geschrieben

ich hab nur die klammern um x.*fppointer vergessen, danke dir

super hilfe...

wenn du aber bitte trotzdem noch erklären könntest, warum das inline stehen muss

Geschrieben

Aus einer Templatedefinition wird zunächst einmal kein Code erstellt. Der Code wird erst dann produziert, wenn das Template benutzt wird, und zwar für jeden Templateargument-Typ (bzw. für jede Kombination von Typen bei mehreren Templateargumenten) einmal.

Das hat aber zur Folge, dass die Definition in jeder Übersetzungseinheit verfügbar sein muss, in der sie verwendet wird. In C++ ist dafür das Schlüsselwort export vorgesehen, das aber viele Compiler nicht unterstützen. Daher setzt man die Templatedefinitionen einfach in die Header. Wenn eine cpp-Datei das Template nicht braucht, passiert nichts (siehe oben), und wenn doch, ist der Code da.

Das ist auch der Grund, warum die Container der Standardbibliothek (vector, map usw.) in den jeweiligen Headerdateien implementiert sind.

Dein Kommentar

Du kannst jetzt schreiben und Dich später registrieren. Wenn Du ein Konto hast, melde Dich jetzt an, um unter Deinem Benutzernamen zu schreiben.

Gast
Auf dieses Thema antworten...

×   Du hast formatierten Text eingefügt.   Formatierung wiederherstellen

  Nur 75 Emojis sind erlaubt.

×   Dein Link wurde automatisch eingebettet.   Einbetten rückgängig machen und als Link darstellen

×   Dein vorheriger Inhalt wurde wiederhergestellt.   Editor leeren

×   Du kannst Bilder nicht direkt einfügen. Lade Bilder hoch oder lade sie von einer URL.

Fachinformatiker.de, 2024 by SE Internet Services

fidelogo_small.png

Schicke uns eine Nachricht!

Fachinformatiker.de ist die größte IT-Community
rund um Ausbildung, Job, Weiterbildung für IT-Fachkräfte.

Fachinformatiker.de App

Download on the App Store
Get it on Google Play

Kontakt

Hier werben?
Oder sende eine E-Mail an

Social media u. feeds

Jobboard für Fachinformatiker und IT-Fachkräfte

×
×
  • Neu erstellen...