this an funktion übergeben

Ariakas

Hi!

Ich hab vor ein paar Wochen mit C++ angefangen (habe vorher aber schon mit diversen anderen Programmiersprachen gearbeitet).
Ich habe zur zeit ein kleines Problem mit dem this zeiger einer Klasse.

Wie kann ich this, an eine funktion übergeben?

class foobar
{
    public:
        foobar() {};
        void rufMich() { machWasMitFoobar::machWas( this ); } // wie?
        void gibWasAus( int i ) { ... }
};

class machWasMitFoobar
{
    public:
        static void machWas( foobar* fb ) // wie?
        {
            fb->gibWasAus( 1 );
        }
};

Ich weiss, das Programm wird so nciht laufen, aber das sein mal dahin gestellt
Wie müssen die zeilen für den aufruf und die deklaration der Funktion machWas sein, damit ich this übergeben kann?

Komme noch sehr mit den Zeigern usw durch einander, das ist neuland für mich. Hab auch nix passendes zu meinem Probelm im Inet gefunden.
Vielleicht kann ja einer von euch helfen.

Thx, Ari

unskilled

//foobar
#include "machwasmitfoobar.h"

class foobar
{
    public:
        foobar() {};
        void rufMich() { machWasMitFoobar::machWas( this ); } // wie?
        void gibWasAus( int i ) { ... }
};

natürlich auch noch in cpp/h trennen, dann musst du hier im header nix mehr includen..

//machwasmitfoobar.h
class machWasMitFoobar
{
    public:
        static void machWas( class foobar* fb );
};

//machwasmitfoobar.cpp
#include "machwasmitfoobar.h"
#include "foobar.h"

void machWasMitFoobar::machWas(foobar *these)
{
  these->foo();
}

oder wo lag das problem?

bb

include guards bzw. #pragma once wären vermutlich auch nicht schlecht.

Soweit ich das verstanden habe, willst du ein Objekt der Klasse foobar an eine statische Funktion einer anderen Klassen übergeben. Hier mein Tipp:

class foobar(); // Vorwärtsdeklaration, damit du einen Zeiger auf foobar erstllen kannst

class machWasMitFoobar 
{
    public:
        static void machWas(foobar *fb){fb->gibWasAus(1);} // Besitzt zwar keinen eigenen this-Zeiger, kann dafür aber immer noch Klassenobjekte übernehmen.
};

class foobar // Besitzt eine Funktion, die eine statische Funktion einer andern Klasse aufruft
{
    public:
        foobar(){}
        void rufMich(){machWasMitFoobar::machWas(this);} // this==Adresse, wird in machWasMitFoobar::machWas() automatisch in einen Zeiger verwandelt.
        void gibWasAus(int i){(...)}
};

Kurze Anmerkung: die Klammern nach dem Klassennamen foobar in der allerersten Zeile ignorieren.

unskilled

forward deklaration wird dort kaum reichen...
aber ok - wieso auch mal meinen vorschlag lesen, der gehen sollte - lieber selbst noch mal was posten, in dem man ein viertel der lösung kopiert und hofft, dass es auch reicht ~~

bb

Wieso sollte eine Vorwärtsdeklaration nicht reichen? Der Compiler weiss zu dem Zeitpunkt zwar noch nicht (wenn der die Klasse "machWasMitFoobar" definiert), wie viel Speicher foobar braucht (weshalb man noch kein foobar-OBJEKT erstellen kann), aber ein ZEIGER braucht nur vier Bytes, um auf ein späteres foobar-Objekt zu zeigen, daher geht dies. Sonst wären verkettete Listen ja auch nicht möglich.

Mir fällt gerade auf, dass dein (unskilled) Lösungsvorschlag lautet, eine Klasse in eine Headerdatei zu verpacken. Denk mal nach:

class foobar
{
public:
        foobar(){};
        void rufMich(){(...)} // Diese Funktion muss wissen, was ein "machWasMitFoobar" ist ...
};

class machWasMitFoobar
{
public:
    static void machWas(foobar *fb){(...)} // und diese Funktion muss wissen, was ein "foobar" ist.
};

Egal, wie man die Definitionen der Klassen stellt, die beiden Objekte müssen voneinander wissen, sonst kommt bei rufMich() der Fehler "machWasMitFoobar::machWas()" : Nichtdeklarierter Bezeicher" oder "Links von '::' muss sich eine Klasse/Struktur/Namensbereich befinden". Wenn man die Definitionen vertauscht, gilt das selbe für foobar.

Ariakas schrieb:

Ich hab vor ein paar Wochen mit C++ angefangen (habe vorher aber schon mit diversen anderen Programmiersprachen gearbeitet).

Welche zum Beispiel?

Ariakas schrieb:

Ich habe zur zeit ein kleines Problem mit dem this zeiger einer Klasse.
Wie kann ich this, an eine funktion übergeben?
class foobar
{
    public:
        foobar() {};
        void rufMich() { machWasMitFoobar::machWas( this ); } // wie?
        void gibWasAus( int i ) { ... }
};

Das ist kein Problem mit dem this-Zeiger. Dein Problem ist eine fehlende Vorwärtsdeklaration von "machWasMitFoobar::machWas(foobar*)".

Wenn es unbedingt eine inline-definition für rufmich sein muss:

class foobar; // Vorwärtsdeklaration

void machwas(foobar*); // Vorwärtsdeklaration

class foobar
{
public:
  void rufmich() {machwas(this);}
  void ausgabe(int i) {/*...*/}
};

void machwas(foobar* zeiger)
{
  zeiger->ausgabe(42);
}

Beachte: Dies sind Inline-Definitionen für die Elementfunktionen foobar::rufmich und foobar::ausgabe. Damit bittest Du den Compiler diese Funktionen zu "inlinen".

Gruß,
SP

Ariakas

Hi!

Danke für die rege hilfe stellung. Sorry das ich mich so lange nicht gemeldet habe, war im Urlaub

Werde das ganze nachher nochmal probieren.

Vorherige Programmiersprachen: C#, Delphi, Basic, CAL

Ariakas

Hat alles super funktioniert!
Danke!