ich habe ein Problem mit einer Funktion zum ändern der Größe meiner Klasse.

Ich möchte gern eine Code-Duplizierung vermeiden und die Größenänderung so gestalten:

void klasse::resize(int neuzeilen, int neuspalten) {
delete this;
this = new klasse(neuzeilen,neuspalten); //Fehler: this ist kein l-value
}

die festlegung der größe und speicherreservierung habe ich im konstruktor definiert. um den code ( data = new datentyp[m]; for(...) data[i]=new datenyp[n]; ) nicht doppelt eingeben zu müssen, würde ich also gern den konstruktor aufrufen und die größe dadurch verändern.

aber so wie in zeile 3 geht das nicht, weil this kein lvalue ist.
wie geht also also sonst?

nur den konstruktor aufzurufen funktioniert auch nicht. ( klasse(neuzeilen,neuspalten); )

*this = klasse(neuzeilen,neuspalten);

template <class datentyp>
void Matrix<datentyp>::resize(const int iAnzZeilen, const int iAnzSpalten) {
    delete this;

    //hiermit funktioniert es und dies ist auch der code aus dem konstruktor:
    //a=new datentyp*[iAnzZeilen];
    //for(int i=0;i<iAnzZeilen;i++) a[i]=new datentyp[iAnzSpalten];
    //m=iAnzZeilen;
    //n=iAnzSpalten;

    *this = Matrix<datentyp>(iAnzZeilen, iAnzSpalten); //verursacht laufzeitfehler
}

in meiner matrixklasse ist a** das array mit den elementen und m,n die zeilen-/spaltenanzahl.

(bitte keine tipps, welche klassen ich verwenden kann, es geht hierbei eher ums lernen)

das funktioniert leider nicht er versucht, aus nichtreservierten speicher zuzugreifen (laufzeitfehler).

delete this;
    
    ...

    *this = Matrix<datentyp>(iAnzZeilen, iAnzSpalten); //verursacht laufzeitfehler
}

Ist doch logisch: Du gibst vorher den Speicher der Klasse frei und dereferenzierst danach den (inzwischen ungültigen) this-Zeiger. Außerdem solltest du bei solchen Sachen immer aufpassen: Wenn die Klasse nun ganz normal auf dem Stack angelegt wurde und du delete aufrufst, krachts genau so.

mhh .. wie kann ich dann sonst den speicher reservieren und freigeben?
man kann ja dem zeiger this nichts zuweisen, also this = new Matrix<datentyp>(m,n); geht ja nicht.

Lösche einfach alles, was du im Konstruktor mit new angefordert hast und rufe danach den Konstruktor auf.

void Matrix<datentyp>::resize(const int iAnzZeilen, const int iAnzSpalten) {

    ///genau das steht im Destruktor:
    for(int i=0;i<m;i++) delete[] a[i];
    delete[] a;

    ///das steht im Konstruktor:
    //a=new datentyp*[iAnzZeilen];
    //for(int i=0;i<iAnzZeilen;i++) a[i]=new datentyp[iAnzSpalten];
    //m=iAnzZeilen;
    //n=iAnzSpalten;

    Matrix<datentyp>(iAnzZeilen, iAnzSpalten); //laufzeitfehler!
}

wenn ich nicht den konstruktor aufrufe, sondern den auskommentierten code, funktioniert es ja. aber ich möchte doch lieber den konstruktor verwenden

danke für den tipp!

falls jemandem noch eine andere lösung einfällt, bin ich aber auch noch interessiert

new (this) matrix<datentyp> (iAnzzeilen, iAnzspalten);

aber was machst du, wenn eine exception auftritt?
dann sind nämlich die alten daten alle weg, obwohl sie das nicht sein müssten.

void dings::swap(dings& other)
{
    // in den meisten fällen musst du hier einfach nur alle member-variablen tauschen:
    std::swap(a, other.a);
    std::swap(m, other.m);
    std::swap(n, other.n);
}

dings& dings::operator = (dings const& other)
{
    dings temp(other);  // anderes dings kopieren
    swap(temp);         // dieses dings mit kopie von anderem dings tauschen
    return *this;       // fertig
}

void dings::resize(int newM, int newN)
{
    dings temp(newM, newN); // neues dings erstellen
    // ggf. noch daten von "this" nach "temp" kopieren
    swap(temp);             // dieses dings mit dem neuen dings tauschen
}

in der elementfunktion

new (this) matrix<datentyp> (iAnzzeilen, iAnzspalten);

Wie gesagt eher schlecht, da du vorher evtl. das aktuelle Objekt freigeben musst (wenn es nicht auf dem Stack liegt - was du nicht so einfach feststellen kannst) und du dir dann noch für den Destruktor merken müsstes, wie das aktuelle Objekt erzeugt wurde (entweder vom Programmierer (Finger weg lassen) oder innerhalb des Klassen-Members (delete aufrufen)).