Aufruf einer non static function in einer static function

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • Ja nur wenn du an die membervariable des objectes rankommst, an dem du die non static funktion aufrufen willst ! ^^ Mit obejctvariable isses total easy, ohne gehts einfach ned ! also musst nur irgendwie nen weg finden an deine objectvariable ranzukommen.

    z.b. typisches vorgehen bei multhithreading (wenn man die c schnittstelles des BS unter c++ nutzt, und keine fertige Mt bib)

    Quellcode

    1. class CMultithreading
    2. {
    3. public:
    4. void start() // starten des MT
    5. {
    6. DWORD threadID = 0;
    7. mThreadHandle = CreateThread(NULL,0,ThreadProc,this,0,&threadID );
    8. // hier alles was man noch braucht um fehler abzufangen
    9. }
    10. virtual void run() = 0; // eigene run methode das was im eigenen thread laufen sollt, nicht static, erzwingen einer impl dafuer
    11. private:
    13. static DWORD ThreadProc(LPVOID lparam) // die threadproc muss immer statisch sein
    14. {
    15. // aber zum gluech ist unsere membervariable im uebergabe parameter "versteckt"
    16. CMultithreading * pMyObj = reinterpret_cast<CMultithreading *>(lparam);
    17. // nu einfach die run methode ausfuehren ...
    18. if(pMyObj) pMyObj->run();
    19. }
    21. HANDLE mThreadHandle;
    22. };
    Alles anzeigen


    nur unvollstaendig .... hoffe man sieht das prinzip.
    Sowas braucht man eigentlich nur bei Multithreading, oder wenn man mit c++ clients ueber C schnittstellen (dlls) und handles arbeiten muss ....

    Ciao ...

  • Danke für die schnelle Antwort.
    Mein Problem sieht aber leider eher so aus:


    Header-Deklaration:

    Quellcode

    1. class C_Class1
    2. {
    3. public:
    4. static void v_function1(const C_ParameterClassA& rc_ParameterClassA);
    5. void v_OnParameterClass(const C_ParameterClassB&
    6. rc_ParameterClassB);
    7. .....
    8. }

    CPP-Definition:

    Quellcode

    1. void C_Class1::v_OnParameterClass(const C_ParameterClassB&
    2. rc_ParameterClassB)
    3. {
    4. //mache viele lustige Dinge mit rc_ParameterClassB
    5. }
    7. void C_Class1::v_function1(const C_ParameterClassA& rc_ParameterClassA)
    8. {
    9. C_ParameterClassB objClassB;
    11. //hier wird objClassB modifiziert, so dass es dann weiter verwendet werden kann
    12. rc_ParameterClassA.doSomething(objClassB);
    13. //Aufruf der unteren Funktion ist nicht möglich
    14. v_onParameterClass(objClassB);
    15. }
    Alles anzeigen

    Meine Frage ist nun, gibt es eine Möglichkeit die nicht static Funktion v_onParameterClass(objClassB); in der static funktion v_function1(const C_ParameterClassA& rc_ParameterClassA) aufzurufen?

  • Ok, ich bin's nochmal und glaube mein Problem gelöst zu haben.
    Wie gesagt, kann ich nicht einfach die Funktion "v_onParameterClass(objClassB);
    " aufrufen. Klare Sache, da sie non-static ist und in einer static Funktion "static void v_function1(const C_ParameterClassA& rc_ParameterClassA); "aufgerufen wird.
    Ich habe mir nun für die Klasse C_Class1 eine Factory und ein Interface geschrieben, mit der ich mir eine Instanz von C_Class1 zurückgeben lassen kann und somit zu jeder Zeit ein Objekt der Klasse C_Class1 in der static Funktion habe.
    sieht dann in etwa so aus:
    C_Class1Factory::rc_GetClass1Interface().v_OnParamterClass(objClassB);

  • ja wei gesagt, eine normale memberfunktion aufzurufen geht nur mit gueltiger instanz.
    Intern loest der compiler den membraufruf in einen (globalen)funktionsaufruf mit einem paramater mehr , eben diese this variable, auf.

    also musst du an nen gueltigen wert fuer dieses this rankommen ... (ungueltiger wert der ignoriert wird, geht ned weil sonst intern alle aufrufe auf members voll quer laufen, mal abegsehen davon das es keinen sinn macht, memberfunktionen die keine instanz brauchen, "non static" zu lassen ...

    Wie du an deine Instanz rankommst ist deine sache (globale variable - schlecht, singleton - besser ... uvam)
    Nur wenn du nen singleton anlegst allein nur um diese membervaariable zu bedienen, wuerd ich mein design noch mal ueberschlafen ....

    die frage ist eigentlich, warum ist v_function1 static, wenn sie doch logisch gesehen ne instanz (fuer den memberaufruf) braucht ???

    P.s. Deine namenskonvention bereitet mir schon bisserl augenschmerzen ^^
    C als prefix fuer Klassen ist schon aua, C_ tut ja fast weh ^^
    fuer was steht eigentlich v_ ?
    Gibt aber schlimmeres :)

    Ciao ...

  • v steht für void.
    selbst ausgedacht habe ich mir das auch nicht.
    sind vorgegebene naming conventions...

    ich brauche die Funktion als static Funktion, weil ich später mit einem Funktionszeiger drauf zeige und diesen dann für einen Callback verwende, welchen ich auf Treiberebene verwalte. Achja das ganze läuft embedded, also nicht auf PC Plattform. Obwohl das hier eigentlich keine Rolle spielt.

    Grüße
    micha

  • "Sussi" schrieb:

    P.s. Deine namenskonvention bereitet mir schon bisserl augenschmerzen ^^

    Hab ich mir auch gerade gedacht,sieht echt gruselig aus ....und ist in Bezug auf die Lesbarkeit eher hinderlich :wink:

    Gruß void
    "Probleme kann man niemals mit derselben Denkweise lösen,
    durch die sie entstanden sind." (A. Einstein)

  • ich brauche die Funktion als static Funktion, weil ich später mit einem Funktionszeiger drauf zeige und diesen dann für einen Callback verwende, welchen ich auf Treiberebene verwalte.


    meist musst du aber dann dazu noch den satz an daten wissen, mit denen du die funktion aufrufst ....
    Viele callbackfunktionen arbeiten mit "Handles", z.b. um einen aufrufer zu identifizieren. Das handle ist fuer den verwalter nur nen Handle, also quasi was eindeutiges. Der Holder selbst kann aus dem handle meist das object wieder referenzieren ... meist ist es nur die gecastete version des this zeigers ....

    Schreibst du den treiber selber ? Auf welche schnittstellen bist du beim zugriff auf den treiber beschraenkt ? (wenn du mit c++ arbeiten kannst, solltest du vtables statt callbacks verwenden .... )

    Ciao ...

  • Ich ergänze nur eine bestehende Architektur und bin auf die Callback Variante angewiesen. Zusätzlich zu meinem Funktionszeiger übergebe ich auch noch einen this-Zeiger. Damit identifiert am Ende die Anwendung zu der der Callback hingehört. Ich denke das meinst du mit Handle.
    Am Treiber selbst habe ich nicht viel zu ergänzen.

  • Damit identifiert am Ende die Anwendung zu der der Callback hingehört

    ja genau, und damit musst du doch deinen globalen funktionsaufruf wieder auf nen object, und damit den daten, matchen ....

    sieht ja meist so aus ....

    Quellcode

    1. void globalcallback(void * pcontext)
    2. {
    3. // wir selber bestimmen das was in pcontext steht und in pcontext steht nun nen zeiger auf ne CMyClass Instanz ....
    4. CMyClass * pMyClass = reinterpret_cast<CMyClass*>(pcontext);
    5. // nu kann man nateurlich die memeberfunktionen am object aufrufen
    6. if(pMyClass) pMyClass->doSomething();
    7. }



    Wo ist das problem ?

    wenn man den callbaeck, da man globale functionen hasst, gern versteckt im namensraum der klasse haben wiill, aendert das nix am vorgehen ...
    statische memberfunktionen sind nix anderes als versteckte globale funktionen !


    Quellcode

    1. void CMyClass::staticcallback(void * pcontext)
    2. {
    3. // wir selber bestimmen das was in pcontext steht und in pcontext steht nun nen zeiger auf ne CMyClass Instanz ....
    4. CMyClass * pMyClass = reinterpret_cast<CMyClass*>(pcontext);
    5. // nu kann man nateurlich die memeberfunktionen am object aufrufen
    6. if(pMyClass) pMyClass->doSomething();
    7. }


    Ciao ...

  • anders bekomme ich sie aber nicht in die vorhandene callbackverwaltung integriert.

    Genau ! also um eine function ohne klassenreferenz kommt er nicht drumherum ....
    die statische memberfunktion dazu ist schon das mittel der Wahl bei den vorgegebenen dingen.

    Das was mir "bauchschmerzen" machen wuerd, waere das singelton ^^
    Generell sollten bei der programmierung logische Anforderungen die Impl bestimmen, und nicht technische ...
    Zu deutsch, nen singleton sollt man nehmen wenn man wirklich nen singleton in der logic braucht (100% einzigartige instanz, von ueberall referenzierbar), und nicht als trick um irgendwelche Schnittstellen bedienen zu koennen ....

    In beitraegen weiter oben wurden Handles erwaehnt ... ich weiss ned wie die organisiert sind, aber normal nimmt man eben die dazu her um genau diese, ansonsten notwendigen, globalen referenzen zu umgehen.
    Und felxibler wirds dadurch auch, da man evtl mehrere clientzugriffe in eine uebersetzungseinheit einbauen koennt, wo man mit einer globalen referenz nicht hinkommen wuerd ....

    Ciao ...