Zeiger auf eine Instanz eines Objektes: Zugriff auf Instanz von Methode anderer Klasse



  • Guten Abend,

    ich hoffe die lange Überschrift verwirrt nicht, ich versuche es nun nochmal etwas klarer zu machen.

    Ich habe ein Programm dass verschiedene Klassen besitzt. Alle Klassen besitzen ihre eigene Header-Datei sowie ein dazugehöriges .CPP

    In main.cpp erzeuge ich Instanzen einer jeden Klasse.

    Aus einer Methode der Klasse Auto möchte ich nun bestimmte Werte einer Instanz der Klasse Karte aufrufen um diese zu verarbeiten.

    Code Auszug:

    Klasse Auto
    
    void Auto::faehrt(string aktion)
    {
    	int x=0,y=0;
    	if(aktion == "rechts")
    			{
    				Karte::flushElement(Auto::getPositionX(),Auto::getPositionY());
    				x=Auto::getPositionX()+1;
    				y=Auto::getPositionY();
    				Auto::setPositionX(x);
    				Auto::setPositionY(y);
    				//auto1.faehrt();
    				Karte::setAuto(x,y);
    				Karte::getKartefull();
    			} 
    			else if(kommando == "links")
    			{
    				Karte::flushElement(Auto::getPositionX(),Auto::getPositionY());
    				x=Auto::getPositionX()-1;
    				y=Auto::getPositionY();
    				Auto::setPositionX(x);
    				Auto::setPositionY(y);
    				//auto1.faehrt();
    				Karte::setAuto(x,y);
    				Karte::getKartefull();
    			}
    			else if(kommando == "hoch")
    			{
    				Karte::flushElement(Auto::getPositionX(),Auto::getPositionY());
    				x=Auto::getPositionX();
    				y=Auto::getPositionY()-1;
    				Auto::setPositionX(x);
    				Auto::setPositionY(y);
    				//auto1.faehrt();
    				Karte::setAuto(x,y);
    				Karte::getKartefull();
    			}
    			else if(kommando == "runter")
    			{
    				Karte::flushElement(Auto::getPositionX(),Auto::getPositionY());
    				x=Auto::getPositionX();
    				y=Auto::getPositionY()+1;
    				Auto::setPositionX(x);
    				Auto::setPositionY(y);
    				//auto1.faehrt();
    				Karte::setAuto(x,y);
    				Karte::getKartefull();
    			}
    };
    
    Methoden der Klasse Karte:
    void Karte::getKartefull()
    {
    	for(int x=0;x<20;x++) // Karteninhalt ausgeben komplett
    		{
    			for(int y=0;y<30;y++)
    			{
    				std::cout << karte[x][y];
    			}
    			std::cout << std::endl;
    		}
    };
    
    void Karte::setAuto(int x,int y)
    {
    	x=x-1;
    	y=y-1;
    	if(karte[y][x]=='.')
    		karte[y][x]='A';
    };
    
    void Karte::flushElement(int x,int y)
    {
    	x=x-1;
    	y=y-1;
    	karte[y][x]='.';
    };
    

    Mit dem Aufruf in Auto über Karte::Methode kommt er nicht klar:

    error C2352: 'Karte::flushElement': Unzulässiger Aufruf einer nicht statischen Memberfunktion
    1> g:\h_da\pg 1 praktikum\projekte\aufgabe 4\autospiel\autospiel\karte.h(12): Siehe Deklaration von 'Karte::flushElement'

    für entsprechend alle Aufrufe.

    Ich hoffe es ist verständlich was ich tun will, die Frage ist: Wie realisiere ich das nun am Besten?



  • Nicht-statische Funktionen wie du sie hast musst du immer für eine gegebene Instanz aufrufen:

    class Pixel
    {
    public:
    	int x;
    
    	int getX() { return x; }
    };
    
    int main()
    {
    	Pixel a;
    	a.x = 10;
    	Pixel b;
    	b.x = 20;
    	cout << Pixel::getX();		// Was soll getX() zurückgeben? 10 oder 20?
    	cout << a.getX();			// so ists richtig
    }
    


  • Du hast noch nicht kapiert, wie man Funktionen einer Klasse aufruft.
    Das "Auto::" kann komplett verschwinden und das "Karte::" muss durch "karte.", wobei "karte" eine Instanz von der Klasse Karte ist, ersetzt werden.

    Lies am besten das Kapitel über Klassen in deinem Buch nochmal durch und aktzeptiere, dass der einzig wahre Start von einem Index bei 0 liegt.



  • Tut mir leid Töfffahrer - aber mir scheint es eher als ob du mein Problem nicht verstanden hast.

    Dass ich letztendlich über meine Instanz und . meine Methode aufrufe aus main.cpp, und dazu nicht den Scope verwende, ist mir schon klar.

    Innerhalb der Methoden-Implementierung kannst du jedenfalls nicht mit einer in main.cpp erzeugten Instanz arbeiten.

    Heißt meine Instanz in main.cpp auto1, so kann ich in Auto.cpp nichts mit auto1.faehrt() anfangen. Genauso wenig kann ich in Auto.cpp mit einer Instanz von Karte aus main.cpp was anfangen.

    Und genau das ist es ja, dass das eben NICHT geht Herr Töfffahrer.

    Für den Fall dass es da gar keine Möglichkeit gibt, muss ich es halt irgendwie über main steuern. Schöner wäre es halt anders.



  • Übergib das Objekt als Parameter an die Funktion.

    Allerdings würd ich mir an deiner Stelle noch überlegen, welche Klasse eigentlich für was zuständig sein soll. Warum sollte ein Auto eine Karte kennen?



  • Stefan_B schrieb:

    Heißt meine Instanz in main.cpp auto1, so kann ich in Auto.cpp nichts mit auto1.faehrt() anfangen.

    Suchst du vielleicht nach dem this-Pointer?



  • Michael E. schrieb:

    Übergib das Objekt als Parameter an die Funktion.

    Allerdings würd ich mir an deiner Stelle noch überlegen, welche Klasse eigentlich für was zuständig sein soll. Warum sollte ein Auto eine Karte kennen?

    Genau das versuche ich, komme aber auf keinen gescheiten Nenner.

    Also in main.cpp instanziere ich folgende Objekte:

    Auto auto1;
    Karte spielfeld;

    nun muss ich in der Methode

    Auto::faehrt(string kommando)

    noch irgendwie das Objekt übergeben damit er es nutzen kann da in der Methode faehrt ein Zugriff auf die Karte geschehen soll. Und zwar sollen die veränderten X und Y Werte an Karte übergeben werden, da dort mein Spielfeld ist und so neu gezeichnet werden muss.



  • Habe es.

    Wenn ich Karte.h in Auto.h inkludiere, kann ich mit Karte *XYZ mir einen Pointer holen den ich mit &instanz die adresse meines objektes übergebe.

    dann kann ich in der methode mit xyz->getSomething() zugreifen und das Objekt mainpulieren.


Log in to reply