3. Objekte auf dem Heap -> Methodenzugriff?

Objekte auf dem Heap -> Methodenzugriff?

  • D
     

    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.

    0
  • N

    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

    0
  • D

    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.

    0
  • N

    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

    0
  • D

    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<karte*> 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
    0
  • N

    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

    0
  • D

    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.

    0
  • N

    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

    0
  • D

    Das sind dann 10 Objekte von dem Typ, ja.

    0
  • N

    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

    0
  • D

    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.

    0
  • N

    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<Karte*> 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

    0
  • D

    Wo ist denn jetzt genau noch das Problem?
    Und warum machst du da etwas mit Zeigern? - spielKarten ist ja der std::vector und daher kannst du mit dem auch ganz komfortabel arbeiten.

    0
  • N

    Also ich habe im Endeffekt zehn Zeiger auf zehn verschiedene Kartenobjekte in dem Vector liegen. Jetzt möchte ich nachher wiederum zehn Zeiger auf jeweils einen Zeiger in dem Vector zeigen lassen. Der Sinn dahinter ist der, dass ich diese Zeiger in zehn verschiedene Stacks packen möchte und anstatt 100 Objekte in den zehn Stacks liegen zu haben, lieber Zeiger benutzen möchte. Ich merk schon beim Schreiben, dass das sehr verwirrend klingen mag oO Zusammengefasst möchte ich keine 100 Objekte des Typs Karte erstellen, die ich in meine Stacks packe. Da ich die Kartenobjekte auf dem Heap nicht verändere, sondern nur ihre Werte durch die Zeiger lesen möchte, ist das gefahrlos, denke ich.
    Ich hoffe, du hast verstanden, was ich machen möchte... xD

    Grüße,
    Neras

    0
  • D
     

    std::vector<const karte*> karten[10];

for (int i = 0; i < 10; i++)
    for (int y = 0; y < 10; y++)
        karten[i][y] = &spielKarten[y];

    Wenn spielKarten richtig gefüllt ist, sollte das in etwa so dem entsprechen, was du willst, oder?

    0
  • N

    Wenn ich das von dir versuche, bekomme ich diesen Error:

    error C2440: '=': 'Karte **' kann nicht in 'const Karte *' konvertiert werden

    Grüße,
    Neras

    0
  • D

    Ah. Mist. Nimm das & mal weg.

    0
  • N

    Ok, dass macht er nun. Und wie kann ich jetzt auf die Methoden des Objekts zugreifen?

    cout << karten[0];

    macht er nicht. Kommt ein "Binärer Operator"-Error. Wenn ich

    karten[0].

    mache, kann ich die Methoden des Vectors benutzen, aber ich hab da noch nicht soviel Sinn drin gesehen, sorry ^^°

    Grüße,
    Neras

    0
  • D

    karten ist ja ein vector von std::vector. mit [0] hast du den ersten, dann kannst du mittels karten[0][0] auf die erste Karte im ersten Container zugreifen und da das Zeiger sind mittels des -> Operators.

    karten[0][0]->irgendeine_funktion_von_karte();
    0
  • N

    Der Compiler kompiliert das auch und den Ansatz hatte ich vorhin auch schon, aber wenn ich

    cout << karten[0][0]->getName() << endl;

    eingebe, komme ich soweit, bis diese Ausgabe bearbeitet wird. Dann bricht das Programm mit einem Error "Expression: vector subscript out of range" ab. Heißt das soviel wie, dass ich etwas lesen will, was nicht vorhanden ist?

    Grüße,
    Neras

    0
Anmelden zum Antworten