3. Mehrdimensionale Arrays löschen

Mehrdimensionale Arrays löschen

  • F

    EDIT: Dieser Text bezieht sich nur auf die erste Antwort.

    Ich probiere nun die Initialisierung mit der 1. Möglichkeit.

    Also:

    static const int ZEILEN=7;
static const int SPALTEN=6;

Spielstein*** b=new Spielstein**[ZEILEN];
    for(int i=0;i<ZEILEN; i++) {
      b[i]=new Spielstein*[SPALTEN];
    }

    Fehlt da noch wo ein * in

    b[i]=new Spielstein*[SPALTEN]

    oder wieso wirds nicht richtig initialisiert?
    Fehler ist aber diesmal:

    Spielbrett.h:74: error: `new' cannot appear in a constant-expression                                              
Spielbrett.h:74: error: ISO C++ forbids initialization of member 'b'                                              
Spielbrett.h:74: error: making 'b' static                                                                         
Spielbrett.h:74: error: invalid in-class initialization of static data member of non-integral type 'Spielstein***'

    Und weitere Folgefehler...

    --------

    Okay, ich werde es mal so probieren mit dem Vector. Und statt des Objektes kann ich auch die Adresse speichern, also den Typ Spielstein* angeben, richtig?

    0
  • ?
     

    static const int ZEILEN=7;
static const int SPALTEN=6;

Spielstein** b=new Spielstein*[ZEILEN];

for(int i=0;i<ZEILEN; i++) {
    b[i]=new Spielstein[SPALTEN];
}

    Brauchst natürlich nen Standardkonstruktor für die Spielsteine...

    EDIT: Wie ist denn b definiert?

    0
  • C
    Mod

    Fabulus schrieb:

    Spielstein* brett[ZEILEN][SPALTEN];

    Hier ist ggf. ein delete für die einzelnen Spielsteine notwendig, falls diese per new erzeugt wurden und nicht anderweitig verwaltet werden. Das Array selbst ist ein automatisches Objekt (oder ein Member einer Klasse), ein delete darf diesbezgl. nicht erfolgen.

    Fabulus schrieb:

    static const int ZEILEN=7;
static const int SPALTEN=6;

Spielstein*** b=new Spielstein**[ZEILEN];
    for(int i=0;i<ZEILEN; i++) {
      b[i]=new Spielstein*[SPALTEN];
    }

    Fehlt da noch wo ein * in

    b[i]=new Spielstein*[SPALTEN]

    oder wieso wirds nicht richtig initialisiert?

    Der Fehlermeldung nach sieht das eher so aus, als ob du die Initialisierung direkt in der Klassendefinition durchführen willst.

    0
  • F

    Also ich habe jetzt erst einmal die Klasse array2D geschireben, wie es hier aufgefuehrt wurde.

    Aber es gibt hier jetzt bei der Erstellung dieses Arrays ein Problem:

    Ich erstelle mir:

    array2D<Spielstein*> bret( 6,7 );

    Und es kommt:

    Spielbrett.h:77: error: expected identifier before numeric constant
Spielbrett.h:77: error: expected ',' or '...' before numeric constant

    Sofern ich schreibe (was auch im Endeffekt mein Ziel ist):

    array2D<Spielstein*> bret( ZEILEN,SPALTEN );

    kommt:

    Spielbrett.h:77: error: 'ZEILEN' is not a type                                                                    
Spielbrett.h:77: error: 'SPALTEN' is not a type

    ZEILEN und SPALTEN sind static const int zwei Zeilen darüber erstellt.

    0
  • C
    Mod

    Bitte hinreichend vollständigen Code zeigen. Meine Kristallkugel ist schon vor Jahren zu Bruch gegangen.

    0
  • F

    Meine array2D.h sieht genauso aus, wie von DocShoe beschrieben.

    Ich habe mir ein testprogramm geschrieben, in dem ints in einem array dieser Art gespeichert werden. Das klappt soweit.
    Verwende ich aber das Array in meiner Spielbrett.h, kommt der eben beschriebene Fehler, auch wenn integer die Elemente sein sollen.

    Hier mal der Code:

    #ifndef SPIELBRETT_H
#define    SPIELBRETT_H
#include "Spielstein.h"
#include "array2D.h"

const int Z=6;
const int S=7;

class Spielbrett {

public:

    Spielbrett() { 
      init(); 
    }
    ~Spielbrett() {

    } // destructor

    void init();

    Spielstein& getStein(const int& x, const int& y) const { return *brett[x][y]; }
    // Getter-Methoden
    const int& getZeilen() const { return ZEILEN; }
    const int& getSpalten() const {return SPALTEN; }

    // Umleitung des Ausgabeoperators
    std::ostream& outputToStream(std::ostream& ostr) const;

    int getNextZeile(const int& y) const; // Holt sich die naechste Zeile in Spalte y
    bool setzeStein(const int& y, Spielstein& stein); // Setzt Stein in Zeile y

private:
    // Hoehe und Breite des Feldes festlegen
    static const int ZEILEN=Z;
    static const int SPALTEN=S;

/* ZEILE 77 */    array2D<int> bret(6,7);
    Spielstein* brett[ZEILEN][SPALTEN];

};

    Die Methoden beziehen sich alle noch auf das alte brett, was aber sonst funktioniert.

    0

  • Wer ist denn überhaupt Besitzer des Spielsteins? Irgendwas muss ja verantwortlich sein für die Erzeugung und Zerstörung der Spielsteine, wenn du keine Zeiger, sondern die Spielstein Klasse als Template Parameter benutzt erledigt das array2D für dich.

    Edit:
    Du kannst das array nicht statisch initialisieren, wie es in Zeile 77 geschieht. Benutz´ stattdessen die Initialisierungsliste des Konstruktors:

    class Spielbrett
{
   array2d<Spielstein> Spielsteine_;

public:
   Spielbrett() : Spielsteine_( 6,7 )
   {
   }
}
    0
  • C
    Mod

    Fabulus schrieb:

    Ich erstelle mir:

    array2D<Spielstein*> bret( 6,7 );

    Und es kommt:

    Spielbrett.h:77: error: expected identifier before numeric constant
Spielbrett.h:77: error: expected ',' or '...' before numeric constant

    Für die Initialisierung ist der Konstruktor zuständig. Die Fehlermeldung besagt nur, dass der Compiler eine Typenliste erwartet, weil es sich nach der öffnenden Klammer dort nur um eine Funktionsdeklaration handeln kann.

    0
  • F

    Was meinst du mit "Wer ist Besitzer"? Ich gebe mal zur Ergänzung die Klasse Spielstein an (ist abstrakt, aber das sollte ja kein Problem sein).

    Das große Problem ist dass auch beispielsweise keine Integer-werte im Array speichern kann (so wie oben mal gepostet). Es kommt trotzdem dieser Fehler 😞

    class Spielstein {
public:
    virtual ~Spielstein() {}
    virtual int getColor() const { return farbe; }
    virtual bool isSet() const=0;

    enum Color {grau, rot,blau,gelb};

protected:
    Color farbe;
};

    In einem normalen Array kann ich ja auch die Adressen speichern 😞

    Wenn ich übrigens in meiner Testdatei dieses Array mit <Spielstein*> erstelle, klappt alles wunderbar.

    0

  • Hab meinen Post gerade editiert, da sollte die Lösung drinstehen.

    Der Besitzer der Spielsteine ist das Ding, das mit new die Spielsteine erzeugt und in das Spielbrett einfügt. Wenn du einen Zeigertyp als Template Parameter für array2D benutzt enthält das array2D Objekt nur Nullpointer.

    0
  • F

    Ok, ich habe jetzt den Vector soweit erstellt und allen Elementen eine passende Adresse ausgegeben.
    Muss ich jetzt dennoch dafür einen Destruktor schreiben, oder löscht der Compiler jetzt die Elemente von selber? Also ein Destruktor von der Klasse Spielbrett. Weitere Zeiger oder dynamische Speicher kommen nicht vor.

    Eine andere Frage zur Klasse vector. Soweit ich richtig gesucht habe, gibt es noch keine Methode, um den Inhalt eines Vectors in einen anderen zu kopieren.
    Also habe ich gedacht, ich schreibe mir so eine. Natürlich bin ich dort auf den Iterator gestoßen, der jedes Element einzeln durchgeht.

    Da meine Klasse in einem Headerfile steht, muss ich mit std::vector<T>::iterator it den Iterator erstellen.

    Dies klappt aber soweit nicht. Darf ich denn überhaupt doppelt scopen? Wie umgehe ich das Problem?

    Der Code ist ganz einfach bisher:

    void copy(array2D<T>& arr) {
    std::vector<T>::iterator it=Data_.begin(); // Erstelle iterator
    std::vector<T>::iterator it2=arr.Data_.begin(); // Erstelle zweiten Iterator

    /* Pruefe nach, ob Groesse ausreicht (TODO) */

    while(it!=Data_.end()) {
       *it2=*it;
        it++;
        it2++;
    }
}

    Als Fehler kommt:

    array2D.h: error: expected ';' before 'it'
array2D.h: error: 'it' was not declared in this scope
array2D.h: error: expected ';' before 'it2'
array2D.h: error: 'it2' was not declared in this scope
    0
Anmelden zum Antworten