Perché invertire l’ordine di printf () fornisce output diversi?

#include  int ∗addition(int a, int b){ int c = a + b ; int ∗d = &c ; return d ; } int main (void) { int result = ∗(addition(1, 2)); int ∗resultptr = addition(1, 2); printf(”result = %d\n”, ∗resultptr); printf(”result = %d\n”, result); return 0 ; } 

Questo darà la risposta corretta. Ma è strano che una volta che ho scambiato l’ordine degli ultimi due printf () s, verrà data una risposta anormale.

 printf(”result = %d\n”, result); printf(”result = %d\n”, ∗resultptr); 

Perché? È perché alcune implementazioni interne di printf ()?

Ho aperto l’opzione -Wall ma nessun avviso visualizzato.

Grazie per le tue risposte! È la prima domanda per me su StackOverflow.

Ma perché invertire l’ordine darà risposte diverse? Se è dovuto al comportamento indefinito di restituire una variabile locale, perché il primo programma fornisce la risposta corretta ma il secondo non può, mentre l’unica differenza è l’ordine di printf ()?

In questa funzione,

 int ∗addition(int a, int b){ int c = a + b ; // Object on the stack int ∗d = &c ; // d points to an object on the stack. return d ; } 

stai restituendo un puntatore a un object dalla pila. La memoria restituita non è valida dopo il ritorno dalla funzione. L’accesso a quella memoria porta a un comportamento indefinito.

Se cambi la funzione per restituire un int , le cose andrebbero bene.

 int addition(int a, int b){ return (a + b); } int main (void) { int result1 = addition(1, 2); int result2 = addition(2, 3); printf(”result = %d\n”, result1); printf(”result = %d\n”, result2); return 0 ; } 

Stai restituendo un puntatore a una variabile locale, che viene deallocata dopo che la funzione è terminata (e quindi invoca un comportamento non definito).