void pointerFun(){
Matrix *ma = new Matrix[3];
ma[0] = Matrix(3,3, "st1"); // Gewohnter zugriff

// folgendes will ich probieren (was scheibar auch funktioniert):
ma[2] = (Matrix)(*(new Matrix(6,6, "Name der Matrix"))); // ist das gleiche wie darunter?
((Matrix)ma[2]) = *(new Matrix(6,6, "Name der Matrix"));
/* 
Ich lasse mir beim Destruktoraufruf den Namen der aktuellen Matrix ausgeben; so kann ich die Matritzen in der Konsole besser zuordnen.
*/
}

Zu ma[2] = (Matrix)(*(new Matrix(6,6, "Name der Matrix")));:
Ich allokiere mir also Speicher vom Heap wenn ich mit new ein neues Matrix Objekt erzeuge. Mache ich das so, wird der allokierte Speicher nach verlassen der Methode pointerFun{...} nicht wieder freigegeben. Ich muss delete anwenden.

FRAGE 1: Warum muss ich an dieser Stelle casten? Ich dachte void* Pointer werden nur bei C zurückgegeben und ab C++ sind die gelieferten Pointer welche auf den Speicher für das Objekt im Heap zeigen mit dem selben Datentyp wie das Objekt definiert und ein Cast ist nicht mehr nötig?

FRAGE 2: Warum geht folgendes nicht (Quasi obiges ohne Cast):
ma[2] = *(new Matrix(6,6, "Name der Matrix")); // geht scheibar nicht
ma ist der Pointer auf das Array vom Typ Matrix, durch [] derefernziere ich und erhalte die Stelle im Speicher, an welcher ein Matrix Objekt abgelegt werden kann. Durch *(new...) bekomme ich das passende objekt für diese Stelle?

FRAGE3: Gibt es einen Unterschied zwischen:
ma[2] = *(new Matrix(6,6, "Name der Matrix"));
und
ma[0] = Matrix(3,3, "st1");
Ich dachte das sei das selbe?

Zu ma[0] = Matrix(3,3, "st1");:
Ich allokiere Speicher innerhalb der Methode in einer lokalen Variable vom Stack. Variablen, welche auf diese Art allokiert werden, werden automatisch nach Ende der Methode zerstört (autom. Destruktor- Aufruf).

Stimmt das eurer Meinung nach wie ich das alles beschrieben hab?
Vielen Dank!

ma[2] = (Matrix)(*(new Matrix(6,6, "Name der Matrix")));

Das ist ein sofortiges Speicherleck, und der Cast nimmt dich um drei Ecken. Du forderst ein Objekt auf dem Heap an, merkst dir aber seine Adresse nicht. Dann castest du den Kram von Matrix& nach Matrix, wodurch eine temporäre Kopie erzeugt wird (die der Compiler allerdings wegoptimieren darf) und weist deren Inhalt einem bestehenden Objekt ma[2], das du ein paar Zeilen weiter oben angefordert hast, zu. Da du dir den Zeiger auf das Heap-Objekt nicht merkst, ist der da angeforderte Speicher sofort verloren.

Ich vermute, dass du von Java, C# o.ä. herkommst; man kann die Denkweise darin noch grob erkennen. Merke: Objekte sind in C++ keine Referenztypen! Mit

Matrix *ma = new Matrix[3];

erzeugst du bereits drei Matrix-Objekte in einem Array auf dem Heap; es ist weder erforderlich noch sinnvoll, das später nachholen zu wollen. Übrigens nimmt man dafür besser

std::vector<Matrix> ma(3);

...dann muss man sich nicht selbst um die Aufräumarbeit kümmern (Stichwort RAII). Wenn die Länge zur Compilezeit bekannt ist, geht auch

Matrix ma[3];

oder

std::array<Matrix, 3> ma;

Dann castest du den Kram von Matrix& nach Matrix, wodurch eine temporäre Kopie erzeugt wird (die der Compiler allerdings wegoptimieren darf)

Das ist kein Fall für copy elision. Das Original ist kein temporäres Objekt, und der Cast-Ausdruck selbst wird in einer Zuweisung verwendet (könnte allerdings eine Move-Zuweisung sein).

Diese Zeile
ma[2] = (Matrix)(*(new Matrix(6,6, "Matrix Name")));
ist schlecht, da:
new Matrix besorgt Speicher und liefert Pointer drauf zurück. ma[2] hat bereits ein instanziiertes Matrix Objekt drin. Durch den Zuweisungsoperator (=) wird vom Compiler eine Bitweise (Flache) Kopie erzeugt. Dabei tritt der Effekt auf, dass ich aber immernoch auf die Referenzen des durch new erzeugten Objektes mit ma[2] zugreifen und somit auch verwenden kann, bzw das bei weiterem Zugriff durch ma[2] aktiv tue.

Bei verlassen der Methode void pointerFun(){...} wird das Matrix Objekt hinter ma[2] normal gelöscht (vom Stack), dass mit new erstellte Matrix Objekt aber nicht. Den zeiger darauf habe ich bereits bei der Zuweisung zu ma[2] verloren.

Was soll das "(Matrix)" da überall?

MatzeOneOSix schrieb:

FRAGE 1: Warum muss ich an dieser Stelle casten? Ich dachte void* Pointer werden nur bei C zurückgegeben und ab C++ sind die gelieferten Pointer welche auf den Speicher für das Objekt im Heap zeigen mit dem selben Datentyp wie das Objekt definiert und ein Cast ist nicht mehr nötig?

Richtig gedacht. Da musst Du wohl noch etwas anderes falsch gemacht haben.

MatzeOneOSix schrieb:

FRAGE 2: Warum geht folgendes nicht (Quasi obiges ohne Cast):
ma[2] = *(new Matrix(6,6, "Name der Matrix")); // geht scheibar nicht
ma ist der Pointer auf das Array vom Typ Matrix, durch [] derefernziere ich und erhalte die Stelle im Speicher, an welcher ein Matrix Objekt abgelegt werden kann. Durch *(new...) bekomme ich das passende objekt für diese Stelle?

müsste so gehen, obwohl du natürlich sofort ein Speicherleck bekommst, da du per new ein Objekt anlegst, es kopierst, die Addresse darauf vergisst und das Original noch im Speicher hängen bleibt.

MatzeOneOSix schrieb:

FRAGE3: Gibt es einen Unterschied zwischen:
ma[2] = *(new Matrix(6,6, "Name der Matrix"));
und
ma[0] = Matrix(3,3, "st1");
Ich dachte das sei das selbe?

Ja das ist unterschiedlich. Nein, das ist nicht dasselbe.

MatzeOneOSix schrieb:

Zu ma[0] = Matrix(3,3, "st1");:
Ich allokiere Speicher innerhalb der Methode in einer lokalen Variable vom Stack. Variablen, welche auf diese Art allokiert werden, werden automatisch nach Ende der Methode zerstört (autom. Destruktor- Aufruf).

Das hast Du richtig erkannt. *new Matrix(...) legt das Ding aber nicht im automatischen Speicher an, sondern im Freispeicher, wo es nicht automatisch wieder gelöscht wird. Also: Speicherleck

#include <vector>

...

void erst_mal_mit_krabbeln_anfangen()
{
  vector<Matrix> vec;
  vec.reserve(2);
  vec.emplace_back(3,3,"str");             // C++2011
  vec.emplace_back(6,6,"Name der Matrix"); // C++2011
}

oder

#include <vector>

...

void erst_mal_mit_krabbeln_anfangen()
{
  vector<Matrix> vec (2);

  vec[0] = Matrix(3,3,"str"); // Zuweisung

  // oder
  vec[1].reset(6,6,"Name der Matrix"); 
  // falls die Matrix-Klasse eine entsprechende
  // reset-Funktion besitzt.
}

Zu jedem new gehört ein delete. Zu jedem new[] gehört ein delete[]. Mittlerweile sind wir bei C++ so weit, dass wir delete[] und delete nur ganz ganz selten selbst schreiben müssen, weil wir entweder die Verantwortung zum Löschen sofort an ein schlaues Objekt abtreten (smart pointer) oder weil wir gleich einen passenden Container nehmen können, wie z.B. vector. Man kann also an wirklich vielen Stellen durch einen modernen Stil new[], delete[] und delete vermeiden, ohne dass dadurch Speicherlecks entstehen.

MatzeOneOSix schrieb:

Diese Zeile
ma[2] = (Matrix)(*(new Matrix(6,6, "Matrix Name")));
ist schlecht, da:
new Matrix besorgt Speicher und liefert Pointer drauf zurück.

Soweit richtig.

MatzeOneOSix schrieb:

ma[2] hat bereits ein instanziiertes Matrix Objekt drin. Durch den Zuweisungsoperator (=) wird vom Compiler eine Bitweise (Flache) Kopie erzeugt.

Jain. Wenn Du keinen eigenen Zuweisungsoperator definiert hast, versucht der Compiler hier elementweise zuzuweisen. Was dabei passiert, hängt natürlich von den Elementtypen an und ob deren Zuweisungsoperator überschrieben wurde und so weiter. Wenn Du also Deine Matrixelemente in der Klasse in einem std::vector speicherst, wird natürlich KEINE "flache Kopie" erzeugt, da der Zuweisungsoperator des vectors die Elemente auch kopiert.

MatzeOneOSix schrieb:

Dabei tritt der Effekt auf, dass ich aber immernoch auf die Referenzen des durch new erzeugten Objektes mit ma[2] zugreifen und somit auch verwenden kann, bzw das bei weiterem Zugriff durch ma[2] aktiv tue.

Nicht wirklich. Was für Referenzen? Wo sind denn da Referenzen? Nach der Zuweisung hast Du keine Möglichkeit mehr, auf das im Freispeicher erzeugte Objekt zuzugreifen, weil Du Dir ja nicht mal die Adresse darauf merkst. Ich befürchte, Du verstehst das C++ Objekt-Modell nicht. Es zwingt Dir nicht, wie es andere Sprachen gern tun, eine Indirektion auf (z.B. "Referezen" in Java und Python).

MatzeOneOSix schrieb:

Bei verlassen der Methode void pointerFun(){...} wird das Matrix Objekt hinter ma[2] normal gelöscht (vom Stack), dass mit new erstellte Matrix Objekt aber nicht. Den zeiger darauf habe ich bereits bei der Zuweisung zu ma[2] verloren.

Das klingt richtig. Aber so ganz sitzt das noch nicht, oder?