Objekte auf dem Heap -> Methodenzugriff?

Reply to Objekte auf dem Heap -> Methodenzugriff? on Sat, 07 Mar 2009 20:45:07 GMT

Neras — Sat, 07 Mar 2009 20:45:07 GMT

Hallo,

ich habe ein kleines Problem mit Objekten, die ich auf dem Heap erzeugt habe. Hier erstmal der Code:

Karte *koenigKarte1 = new Karte(*stapelAuswahl);

stapelAuswahl ist in dem Fall ein Zeiger auf die erste Stelle eines Arrays.

Das Problem ist nun, dass ich außerhalb der Klasse, in der ich das Objekt so erzeugt habe, nicht darauf zugreifen kann. Soweit ich das verstanden habe, sollte das Objekt doch auch nach der Laufzeit der Klasse noch zugänglich sein, oder? Ich versuche, das Objekt in der main mit folgendem Befehl anzusprechen:

koenigKarte->getName();

getName() ist natürlich eine Methode des Objekts Karte.
Kann mir da einer weiterhelfen?

Grüße,
Neras

Reply to Objekte auf dem Heap -> Methodenzugriff? on Sat, 07 Mar 2009 21:03:38 GMT

devkid — Sat, 07 Mar 2009 21:03:38 GMT

Hm... Ist das jetzt ein Tipp-Fehler oder steht bei dir im Programm auch einmal koenigKarte1 und einmal koenigKarte? Du hast ja nicht beschrieben, wo der Fehler auftaucht.

Reply to Objekte auf dem Heap -> Methodenzugriff? on Sat, 07 Mar 2009 21:06:48 GMT

Neras — Sat, 07 Mar 2009 21:06:48 GMT

Ups, dass ist ein Tippfehler hier im Forum xD Es soll natürlich so heißen:

koenigKarte1->getName();

Die Fehler, die beim Compilieren kommen, sind folgende:

error C2065: 'koenigKarte1': nichtdeklarierter Bezeichner
error C2227: Links von "->getName" muss sich ein Zeiger auf Klassen-/Struktur-/Union-/generischen Typ befinden.

Grüße,
Neras

Reply to Objekte auf dem Heap -> Methodenzugriff? on Sat, 07 Mar 2009 21:09:22 GMT

devkid — Sat, 07 Mar 2009 21:09:22 GMT

Naja, steht die Karte *koenigKarte1 = new Karte(*stapelAuswahl); genau so im Code? Wie soll main die Variable dann kennen, wenn du das in einer Klassenmethode machst?

Reply to Objekte auf dem Heap -> Methodenzugriff? on Sat, 07 Mar 2009 21:14:08 GMT

Neras — Sat, 07 Mar 2009 21:14:08 GMT

Hmmm...
Kannst du mir dann vielleicht einen Tipp geben, wie ich das lösen könnte? Ich habe eine Klasse Karte, von der ich mehrere Objekte erzeugen möchte. Dazu benutze ich zurzeit die Klasse Kartenfabrik. Ich weiß jetzt nicht, was du alles wissen musst, deswegen erstmal die Idee, die ich habe.

Grüße,
Neras

Reply to Objekte auf dem Heap -> Methodenzugriff? on Sat, 07 Mar 2009 21:21:10 GMT

devkid — Sat, 07 Mar 2009 21:21:10 GMT

class Kartenfabrik
{
    public:
        Karte* erzeugeKarte ()
        {
            Karte *karte = new Karte ();
            return karte;
        }
};

Kartenfabrik kf;
Karte *karte = kf.erzeugeKarte ();
karte->getName ();

Reply to Objekte auf dem Heap -> Methodenzugriff? on Sat, 07 Mar 2009 21:47:02 GMT

drakon — Sat, 07 Mar 2009 21:47:02 GMT

stapelAuswahl ist in dem Fall ein Zeiger auf die erste Stelle eines Arrays.

Das ist da schon mal falsch. Das ist lediglich ein Zeiger auf eine Karte.

Dann verstehe ich das so, dass du dein Obejkt von überall zugreifbar haben willst, aber das ist keine gute Idee. Wenn du Infos haben willst, kannst du das über Memberfunktionen zurückgeben, oder allenfalls eine Funktion haben, die dir einen Zeiger/Referenz auf das Obejekt zurückgibt.

Die Methode von devkid ist gefährlich, da nicht klar ist, wer denn jetzt für die Verwaltung des Speichers zuständig ist. Man kann das gleich so lösen, dass die Fabrik das Objekt verwaltet, allerdings hat man ein Problem, wenn das Objekt ungültig ist, dass da immernoch Zeiger drauf verweisen können. Da würden dann Smart Pointer wieder helfen.

Eine andere Möglichkeit wäre, dass man eine Funktion der Fabrik hat, die den Speicher wieder freigibt ( free_card(card* c), oder so). Den Aufruf überlässt man dann wieder dem Erzeuger der Klasse.

Reply to Objekte auf dem Heap -> Methodenzugriff? on Sat, 07 Mar 2009 21:53:09 GMT

devkid — Sat, 07 Mar 2009 21:53:09 GMT

drakon schrieb:

Das ist lediglich ein Zeiger auf eine Karte.

Wenn er sagt, dass es ein Zeiger auf ein Array ist, wird das schon stimmen. Woher willst du wissen, dass es anders ist? (Ich glaube du solltest dir die Code-Zeile noch mal angucken. )

drakon schrieb:

Die Methode von devkid ist gefährlich, da nicht klar ist, wer denn jetzt für die Verwaltung des Speichers zuständig ist. Man kann das gleich so lösen, dass die Fabrik das Objekt verwaltet, allerdings hat man ein Problem, wenn das Objekt ungültig ist, dass da immernoch Zeiger drauf verweisen können. Da würden dann Smart Pointer wieder helfen.

Das war jetzt bloß ein Beispiel, dass er return verwenden soll, um an die Member der Klasse zu kommen.

Reply to Objekte auf dem Heap -> Methodenzugriff? on Sat, 07 Mar 2009 22:13:50 GMT

Neras — Sat, 07 Mar 2009 22:13:50 GMT

Die Variable "stapelAuswahl" zeigt auf einen Array, das stimmt soweit schon.
Danke für eure Hilfen! Wenn ich das jetzt richtig verstanden habe, kann ich immer nur aus der Methode, in der ich das Objekt erzeugt habe, darauf zugreifen, oder?

Grüße,
Neras

Reply to Objekte auf dem Heap -> Methodenzugriff? on Sat, 07 Mar 2009 22:05:44 GMT

drakon — Sat, 07 Mar 2009 22:05:44 GMT

devkid schrieb:

drakon schrieb:

Das ist lediglich ein Zeiger auf eine Karte.

Wenn er sagt, dass es ein Zeiger auf ein Array ist, wird das schon stimmen. Woher willst du wissen, dass es anders ist? (Ich glaube du solltest dir die Code-Zeile noch mal angucken. )

Ah, sorry. Mein Fehler. Habe die Bezeichner nicht richtig migelesen.

Reply to Objekte auf dem Heap -> Methodenzugriff? on Sat, 07 Mar 2009 22:09:14 GMT

drakon — Sat, 07 Mar 2009 22:09:14 GMT

Neras schrieb:

Danke für eure Hilfen! Wenn ich das jetzt richtig verstanden habe, kann ich immer nur aus der Methode, in der ich das Objekt erzeugt habe, darauf zugreifen, oder?

Nein. Du kannst den Zeiger ja so rumreichen, wie du willst. Die Bezeichner sind einfach nur lokal gültig. (Also wenn sie in einer Funktion deklariert wurden in der Funktion, wenn sie in einer Klasse definiert wurden nur in Elementmethoden der Klasse usw.)

Das Objekt lebt so lange, wie du es leben lässt (wenn du es dynamisch anforderst). Und zugreifen kann jeder, der einen Zeiger darauf besitzt.

Reply to Objekte auf dem Heap -> Methodenzugriff? on Sat, 07 Mar 2009 22:13:29 GMT

Neras — Sat, 07 Mar 2009 22:13:29 GMT

Ah, ok, das hab ich jetzt verstanden ^^
Wenn ich jetzt das Beispiel von devkid nehme und folgendes schreibe:

Karte *koenigKarte1 = spiel.karteErzeugen(pStapelAuswahl);

(pStapelAuswahl ist der Zeiger auf den Array von eben, heißt jetzt nur anders =D) wie kann ich dann einen Zeiger oder ähnliches erzeugen, um auf das Objekt von "überall" her aus zuzugreifen? "Überall" halt in dem Sinne, wer alles den Zeiger hat

Grüße,
Neras

Reply to Objekte auf dem Heap -> Methodenzugriff? on Sat, 07 Mar 2009 22:19:28 GMT

drakon — Sat, 07 Mar 2009 22:19:28 GMT

Üblicherweise sind Fabrikfunktionen ja statisch, aber egal.

Das rumreichen geschieht dann über setter und getter..

foo f;
bar b;

b.set_karte ( f.get_karte() );

b.mache_irgendetwas_mit_kart ();

Reply to Objekte auf dem Heap -> Methodenzugriff? on Sat, 07 Mar 2009 22:25:23 GMT

Neras — Sat, 07 Mar 2009 22:25:23 GMT

Kannst du mir das genauer erklären, was du damit meinst, dass Fabrikfunktionen normalerweise statisch sind? Meine Fabrik stellt die Karten des Spiels her und gibt sie dann an die Spielverwaltung zurück.

Zu deinen Gettern und Settern:
Ich habe das schon versucht, doch wie soll ich dem Getter sagen, welches Objekt er zurückgeben soll, wenn ich doch momentan sowieso nur aus der einen Methode auf die Objekte zugreifen kann?

Grüße,
Neras

Reply to Objekte auf dem Heap -> Methodenzugriff? on Sat, 07 Mar 2009 22:34:11 GMT

drakon — Sat, 07 Mar 2009 22:34:11 GMT

class foo
{
   public:
   static foo* create ();

   private:
   foo(); //private aus welchen gründen auch immer
};

...

foo::create(); //nur über diese Funktion erstellen und muss daher statisch sein,da das hier:
foo f; //nicht geht, da default ctor private ist.

Beim anderen weiss ich nicht genau, was du meinst. Zeig mal konzeptionellen Code. Ich denke mal, dass du da was falsch designst.

Reply to Objekte auf dem Heap -> Methodenzugriff? on Sat, 07 Mar 2009 22:40:06 GMT

Neras — Sat, 07 Mar 2009 22:40:06 GMT

Main:

Spielverwaltung neuesSpiel;

(Aufruf der Spielverwaltung)

Klasse Spielverwaltung:

spielStarten();

(im Konstruktor wird das Spiel gestartet)

Methode spielStarten() aus Spielverwaltung:

Kartenfabrik spiel(pStapelAuswahl);
Karte *koenigKarte1 = spiel.karteErzeugen(pStapelAuswahl);

(Hier wird eine neue Kartenfabrik erzeugt, womit dann ein Objekt des Typs Karte erstellt wird.)

Methode karteErzeugen() aus Kartenfabrik:

Karte* Kartenfabrik::karteErzeugen(string *stapelAuswahl)
{
	Karte *karte = new Karte(*stapelAuswahl);
    return karte;
}

(Das ist die Methode, die oben in spielStarten() benutzt wird.)

Ich hoffe, du kannst mir daran weiterhelfen ^^°

Grüße,
Neras

Reply to Objekte auf dem Heap -> Methodenzugriff? on Sat, 07 Mar 2009 22:49:33 GMT

drakon — Sat, 07 Mar 2009 22:49:33 GMT

Wo ist das Problem? - koenigKarte1 zeigt ja auf eine Karte, die in der Fabrik erzeugt wurde..

Die Karten werden ja, so, wie ich das sehe in Spielverwaltung erzeugt und du willst da drin auf die Karten zugreifen, oder? - Das ist ja kein Problem, da du die Karten ja speichern kannst.

Reply to Objekte auf dem Heap -> Methodenzugriff? on Sat, 07 Mar 2009 22:59:05 GMT

Neras — Sat, 07 Mar 2009 22:59:05 GMT

Sorry, wenn ich jetzt ziemlich auf dem Schlauch stehe, aber ich weiß nicht, wie ich auf die Objekte zugreifen soll. Jede Karte (es sind 10 Stück) wird mit

Karte *koenigKarte1 = spiel.karteErzeugen(pStapelAuswahl);

erzeugt und das in einer Methode der Spielverwaltung. Wenn ich jetzt in einer anderen Methode auf die Methoden der Karte zugreifen möchte, geht das aus irgendwelchen Gründen nicht. Ich nehme mal an, dass

koenigKarte1->getName();

falsch ist?! Im Endeffekt soll der Ablauf so aussehen:
1. Erstelle 10 Objekte des Typs Karte auf dem Heap in der Spielverwaltung mit der Methode aus der Kartenfabrik.
2. Greife aus der Spieleverwaltung auf die Methoden der erstellten Objekte zu.
Grüße,
Neras

Reply to Objekte auf dem Heap -> Methodenzugriff? on Sat, 07 Mar 2009 23:03:31 GMT

drakon — Sat, 07 Mar 2009 23:03:31 GMT

Ich gehe jetzt mal davon aus, dass du die Karten in einer Schleife erzeugst.

Dann kansnt du doch die Zeiger ganz einfach in einen Container pushen.

std::vector karten; //in kartenverwaltung
...
while (..)
{
Karte *koenigKarte1 = spiel.karteErzeugen(pStapelAuswahl);	
karten.push_back ( koenigKarte1 ); //pushen
}

...

//irgendwann
std::cout << karten[0]; //oder sont was mit dem ersten Element machen

Reply to Objekte auf dem Heap -> Methodenzugriff? on Sat, 07 Mar 2009 23:06:52 GMT

Neras — Sat, 07 Mar 2009 23:06:52 GMT

Wie kann ich 10 Objekte in einer Schleife erstellen, die dann alle koenigKarte1 heißen? Oder verkenne ich das gerade? Momentan habe ich zehn new-Anweisungen, die mir meine Objekte erzeugen.

Grüße,
Neras

Reply to Objekte auf dem Heap -> Methodenzugriff? on Sat, 07 Mar 2009 23:12:45 GMT

drakon — Sat, 07 Mar 2009 23:12:45 GMT

Das ist nur ein temporäres Objekt, dass nur die Zeiger hält, welcher ja gleich wieder gepusht wird und somit nicht mehr wichtig ist.

Allerdings habe ich das Gefühl, dass du den Sinn von dynamsichen Speicher nicht ganz begriffen hast.

Warum hast du z.B nicht einfach ein Array von Karten, wo alle drin sind?

Karte karten[10];

Ganz einfach.

Reply to Objekte auf dem Heap -> Methodenzugriff? on Sat, 07 Mar 2009 23:19:15 GMT

Neras — Sat, 07 Mar 2009 23:19:15 GMT

Der Sinn von dynamischem Speicher ist für mich an dieser Stelle, dass ich entscheiden kann, wielange meine Kartenobjekte leben, was für mich zu dem Zeitpunkt, an dem ich über die Implementierung nachgedacht habe, wichtig war.

Wenn ich Karte karten[10] schreibe, dann habe ich ja nur einen Container für meine Karten, richtig? Dann erstelle ich meine Objekte und speichere sie in den Array?

Grüße,
Neras

Reply to Objekte auf dem Heap -> Methodenzugriff? on Sat, 07 Mar 2009 23:23:51 GMT

drakon — Sat, 07 Mar 2009 23:23:51 GMT

Das sind dann 10 Objekte von dem Typ, ja.

Reply to Objekte auf dem Heap -> Methodenzugriff? on Sat, 07 Mar 2009 23:49:04 GMT

Neras — Sat, 07 Mar 2009 23:49:04 GMT

Die Antwort war ja jetzt denkbar knapp gehalten
Wenn ich allerdings versuche, in meiner Spielverwaltung ein Kartenarray zu erzeugen, dann spuckt mir der Compiler den Fehler aus, dass kein geeigneter Standardkonstruktor verfügbar ist.

Grüße,
Neras

Reply to Objekte auf dem Heap -> Methodenzugriff? on Sun, 08 Mar 2009 11:46:11 GMT

drakon — Sun, 08 Mar 2009 11:46:11 GMT

Dann stellst du den halt zur Verfügung. (und machst die Initialisierungswerte halt nachher rein). Oder benutzt gleich einen Container, à la std::vector, std::tr1::array oder boost::array. Die kannst du auch mit einem selbst definiertem Konstruktor benutzen.

Das Problem ist halt, dass du einen riesen Umweg machen willst, der überhaupt nicht nötig ist und daher verstehe ich nicht ganz, was du willst.

Reply to Objekte auf dem Heap -> Methodenzugriff? on Sun, 08 Mar 2009 11:53:01 GMT

Neras — Sun, 08 Mar 2009 11:53:01 GMT

Ok, ich habe es jetzt mit dem vector geschafft... ich weiß nicht, warum es gestern nicht geklappt hat... vielleicht wars einfach zu spät xD Es sieht jetzt so aus:

int y = 0;
	while(y < 10)
	{
		Karte *koenigKarte1 = karteErzeugen(stapelAuswahl);
		karten.push_back(koenigKarte1);
		stapelAuswahl++;
		y++;
	}

Dann übertrage ich den Vector aus der Kartenfabrik in die Spielverwaltung:

vector Kartenfabrik::getKarten()
{
	return karten;
}

Kartenfabrik spiel(pStapelAuswahl);
	spielKarten = spiel.getKarten();

Und dann versuche ich einen Zeiger auf die erste Stelle des Vectors zu erstellen:

Karte** koenigKarte1;
[...]
koenigKarte1 = &spielKarten[0];

Ob das jetzt auf den ersten Blick Sinn ergibt, ist egal, jedoch hat sich da bei mir ein Fehler eingeschlichen, da ich nicht auf das Kartenobjekt zugreifen kann, wenn ich den Zeiger benutze.

Grüße,
Neras