wozu Destruktor explizit schreiben?

Nathan

kollja21 schrieb:

Nathan schrieb:

Ja, aber wenn du im Konstruktor new schreibst, musst du im Destruktor delete schreiben.

Meine Frage ist, wozu man überhaupt im Konstruktor(einer Funktion) mit new oder ohne etwas erzeugen sollte, wenn man es außerhalb des Konstruktors nutzen möchte, wenn man doch keinen Zugriff darauf hat? Oder irre ich mich?

Siehe meinen neuesten Post.

@kollja21:
Du hast wirklich keinen Schimmer, aber davon ganz schön viel! Wie hast du bloß die Schule geschafft?

kollja21

Nathan schrieb:

dann musst du die Variable im privaten Bereich anlegen. Aber du weißt du nicht wie groß der Speicher sein wird, sagst du? Ja, das weißt du nicht. Also kannst du lediglich einen Pointer anlegen*. Im Konstruktor weißt du wie groß der Speicher sein wird, also forderst du Speicher der entsprechenden Größe an. In diesem Fall musst du den dann auch im Destruktor löschen.

ok, das macht Sinn. Meine Variable ist eine Matrix. Kannst du mir kurz hinschreiben, wie ein Pointer auf eine 2D-Matrix unbestimmter Größe aussieht? bitte

asc

kollja21 schrieb:

...Kannst du mir kurz hinschreiben, wie ein Pointer auf eine 2D-Matrix unbestimmter Größe aussieht? bitte

Wieso unbestimmter Größe?
...(int rows, int cols) => Größe ist vorgegeben.

Beispielsweise:
int * matrix = new int[rows*cols];

Swordfish

Das Lustige ist, es steht schon in der Aufgabenstellung:

kollja21 schrieb:

class Bla {
public:
    Bla(int rows, int cols);
    ~Bla();
// weitere Methoden
};
"Implementieren Sie den Konstruktor Bla(int rows, int cols). Dieser soll den für ein Spielfeld mit rows Reihen und cols Spalten benötigten Speicher automatisch allozieren. Legen Sie die für den Zugriff auf das Spielfeld nötigen Variablen im private Bereich der Klasse an. Implementieren Sie außerdem den Destruktor ~Bla(), der den für das Spielfeld allozierten Speicher wieder frei gibt."

class Bla {
private:
    irgendein_typ * field;
public:
    Bla(int rows, int cols)
    {
        // mach was mit field ... *)
    }
    ~Bla();
// weitere Methoden
};

besser: mach was mit field in der Initialisierungsliste ... aber das machen wir dann morgen.

kollja21

asc schrieb:

Wieso unbestimmter Größe?
...(int rows, int cols) => Größe ist vorgegeben.

Beispielsweise:
int * matrix = new int[rows*cols];

rows und cols geben zum Zeitpunkt der Deklaration nur die "Größe"/Anzahl der Dimmensionen an. Also zwei. Aber wie groß die Matrix wird, wird erst im Konstruktor bekannt. Deswegen sagte ich unbestimmter Größe.
das hier: new int[rows*cols] kann ich in der Deklaration nicht verwenden, weil rows und cols selbst noch leer sind. Außerdem würden sie doch multipliziert werden, oder nicht? Dann hätte ich weiterhin ein 1D-Array.

Nathan

kollja21 schrieb:

asc schrieb:

Wieso unbestimmter Größe?
...(int rows, int cols) => Größe ist vorgegeben.

Beispielsweise:
int * matrix = new int[rows*cols];

das hier: new int[rows*cols] kann ich in der Deklaration nicht verwenden, weil rows und cols selbst noch leer sind.

Richtig. Deshalb machst du die Zuweisung des Pointers auch erst im Konstruktor.

Außerdem würden sie doch multipliziert werden, oder nicht? Dann hätte ich weiterhin ein 1D-Array.

Richtig. Aber ein 1D-Array ist das einzige was du bekommen kannst. Mehrdimensionale dynamische Arrays gibt es in C++ nicht*+. Du kannst aber ein eindimensionales Array wie ein mehrdimensionales Array behandeln, musst nur ein paar Indextricks anwenden:

array[x][y] -> array[y * x_size + x] oder array[x * y_size + y]

*Es gibt höchstens ein eindimensionales Array von Pointern auf einzelne Arrays. Das ist aber keine richtige Matrix und total umständlich.
+Genau genommen gibt es auch keine mehrdimensionalen statischen Arrays, der Compiler macht da die selben Tricks wie beschrieben.

kollja21

Nathan schrieb:

(...) *Es gibt höchstens ein eindimensionales Array von Pointern auf einzelne Arrays. Das ist aber keine richtige Matrix und total umständlich.
+Genau genommen gibt es auch keine mehrdimensionalen statischen Arrays, der Compiler macht da die selben Tricks wie beschrieben.

DANKE!!! das ist echt super hilfreich

kollja21

Ich habe den folgenden Code:

class Bla {
private:
	int* Matrix[];
public:
	Bla(int rows, int cols);
	~Bla();
};
Bla::Bla(int r, int c) {
	*Matrix = new int[r * c];
}
Bla::~Bla(void) {
	delete[] Matrix;
}

Und diese Meldung bei Zeile 12: "deleting array '((Bla*)this)->Bla::Matrix' [enabled by default]"
Was bedeutet sie?

Nathan

In Zeile 3 dekarierst du einen Pointer auf ein Array unbestimmter Größe. Das ist quasi ein Pointer auf ein Pointer.
In Zeile 9 weist du diesem Pointer das Ergebnis von new[] zu.
In 12 zerstörst du den Pointer.
Schneller Fix:

delete[] *Matrix;

Besserer Fix:

class Bla {
private:
    int* Matrix; // ein Pointer reicht
public:
    Bla(int rows, int cols);
    ~Bla();
};
Bla::Bla(int r, int c) {
    Matrix = new int[r * c]; // keine Dereferenzierung
}
Bla::~Bla(void) {
    delete[] Matrix;
}

kollja21

1000 Dank, Nathan!!!