Pourquoi cette méthode renvoie -858993460

Question

La méthode printResults() ci-dessous (appelée à partir de la méthode principale en bas) renvoie -858993460 pour les quatre valeurs. Pourquoi est-ce? J'ai confirmé avec les déclarations de cout que les nombres et les calculs sont corrects dans la méthode doCalc(), donc je suppose que l'erreur est dans la façon dont j'utilise des pointeurs et appelle la méthode printResults() ...

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] << "\n\n"; 
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); 

} 

Answer 1

la matrice toReturn seront détruits lorsque les sorties de fonction, vous aurez besoin d'utiliser une certaine forme d'allocation de mémoire persistante (rechercher nouveau et supprimer). En tant que telles, toutes les valeurs ne sont qu'un non-sens.

Answer 2

matrix toReturn; est une variable locale affectée à la pile. Après doCalc renvoie, son contenu est indéfini. Dans ce cas, la mémoire à son ancienne adresse est remplacée par des données aléatoires.

Answer 3

toReturn sera détruit avec le cadre de pile lorsque doCalc est terminé.

Au lieu de renvoyer le pointeur, passez-le à la fonction que vous appelez.

void doCalc (matrices m, matrix* pReturnMatrix) 

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

Answer 4

toReturn est une variable locale dans la fonction doCalc. Il n'existera plus lorsque la fonction reviendra.

Un moyen facile de résoudre ce problème est de passer une référence à la matrice qui stocke le résultat:

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

Ensuite, retirer cette ligne de doCalc:

matrix toReturn; 

Et changer la façon dont la fonction est appelé à partir de ceci:

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

printResult(*calc); 

À ceci:

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

Il existe d'autres façons de résoudre ce problème, par ex. nouveau/supprimer comme suggéré dans d'autres endroits. Cependant, maintenant nous irons dans qui alloue et qui possède la mémoire. Il ne sera pas clair à partir de la signature de la fonction seule qui est responsable de quoi.

Answer 5

Vous pouvez éviter de gérer la mémoire allouée dynamiquement et demander à l'appelant de fournir une valeur lvalue si vous retournez par valeur.

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

    // Code here 

    return toReturn; 
} 

Vous pouvez affecter les résultats à un objet matrix ou l'utiliser dans une expression comme ci-dessous.

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

ou

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