Warum gibt diese Methode zurück --858993460 [duplizieren] - c ++, Zeiger

Die printResults () -Methode unten (wird vom aufgerufenHauptmethode unten) gibt für alle vier Werte -858993460 zurück. Warum ist das? Ich habe mit Cout-Anweisungen bestätigt, dass die Zahlen und Berechnungen innerhalb der doCalc () -Methode korrekt sind. Daher gehe ich davon aus, dass der Fehler in der Art liegt, wie ich Zeiger verwende und die printResults () -Methode aufrufe.

typedef int matrix[2][2] ;

struct matrices {
matrix a;
matrix b;
};

...getInput() method constructs

matrix* doCalc (matrices m){
matrix toReturn;
char input;
cout << "Which calculation would you like to perform - (M)ultiply, (A)dd, (S)ubtract?";
cin >> input;
switch(input){
case "M":
toReturn[0][0] = ((m.a[0][0])*(m.b[0][0]));
cout << "XX " << ((m.a[0][0])*(m.b[0][0]));
toReturn[0][1] = (m.a[0][1]*m.b[0][1]);
cout << "YY " <<  (m.a[0][1]*m.b[0][1]);
toReturn[1][0] = (m.a[1][0]*m.b[1][0]);
toReturn[1][1] = (m.a[1][1]*m.b[1][1]);
break;
case "A":
toReturn[0][0] = (m.a[0][0]+m.b[0][0]);
toReturn[0][1] = (m.a[0][1]+m.b[0][1]);
toReturn[1][0] = (m.a[1][0]+m.b[1][0]);
toReturn[1][1] = (m.a[1][1]+m.b[1][1]);
break;
case "S":
toReturn[0][0] = (m.a[0][0]-m.b[0][0]);
toReturn[0][1] = (m.a[0][1]-m.b[0][1]);
toReturn[1][0] = (m.a[1][0]-m.b[1][0]);
toReturn[1][1] = (m.a[1][1]-m.b[1][1]);
break;
}
return &toReturn;

}

void printResult(matrix m){
cout<<"---RESULT---n";
cout << m[0][0] << "  " << m[0][1] << "n";
cout << m[1][0] << "  " << m[1][1] << "n";

}

void main() {
matrices m = getInput();
cout << m.a[0][0] << "  " << m.a[0][1] << "n";
cout << m.a[1][0] << "  " << m.a[1][1] << "nn";
cout << m.b[0][0] << "  " << m.b[0][1] << "n";
cout << m.b[1][0] << "  " << m.b[1][1] << "n";

matrix* calc = doCalc(m);
matrix c = &calc;

printResult(*calc);

}

Antworten:

2 für die Antwort № 1

die Matrix toReturn Wenn die Funktion beendet wird, werden sie zerstört. Sie müssen eine Form der permanenten Speicherzuordnung verwenden Neu und löschen). Als solche sind alle Werte nur Unsinn.

---

0 für die Antwort № 2

matrix toReturn; ist eine lokale Variable, die auf dem Stack zugewiesen ist. Nach dem doCalc kehrt zurück, der Inhalt ist undefiniert. In diesem Fall wird der Speicher an seiner alten Adresse mit zufälligem Müll überschrieben.

---

0 für die Antwort № 3

toReturn wird mit dem Stapelrahmen zerstört, wenn doCalc ist fertig.

Anstatt den Zeiger zurückzugeben, übergeben Sie ihn an die von Ihnen aufgerufene Funktion.

void doCalc (matrices m, matrix* pReturnMatrix)

matrix* calc = new matrix();
doCalc(m, calc);

---

0 für die Antwort № 4

toReturn ist eine lokale Variable in der doCalc Funktion. Es wird nicht mehr existieren, wenn die Funktion zurückkehrt.

Um dies zu beheben, können Sie einfach eine Referenz an die Matrix übergeben, in der das Ergebnis gespeichert wird:

matrix* doCalc (matrices m, matrix& toReturn ){

Dann entfernen Sie diese Zeile von doCalc:

matrix toReturn;

Und ändern Sie, wie die Funktion von hier aus aufgerufen wird:

matrix* calc = doCalc(m);
matrix* calc = doCalc(m);
matrix c = &calc;

printResult(*calc);

Zu diesem:

matrix calc;
doCalc(m,calc);
printResult(calc);

Es gibt andere Möglichkeiten, dies zu beheben, z. Neu / Löschen wie an anderen Stellen vorgeschlagen. Nun gehen wir jedoch darauf ein, wer die Erinnerung zuweist und wem die Erinnerung gehört. Es ist nicht nur aus der Funktionssignatur klar, wer für was verantwortlich ist.

---

0 für die Antwort № 5

Sie können die Verwaltung des dynamisch zugewiesenen Speichers vermeiden und verlangen, dass der Aufrufer einen Wert liefert, wenn Sie den Wert zurückgeben.

matrix doCalc (const matrices& m)
{
matrix toReturn;

// Code here

return toReturn;
}

Sie können die Ergebnisse einem zuordnen matrix Objekt oder verwenden Sie es in einem Ausdruck wie unten.

if(doCalc(m).a[0][0] == 1)
{
// do something
}

oder

matrix mat(doCalc(m));
if(mat.a[0][0] == 1)
{
// do something
}

---