L'uso di una stringa C fornisce un avvertimento Indirizzo della memoria dello stack associato alla variabile locale restituita - correzione
Le variabili locali sono archiviate in una forma di memoria chiamata memoria stack. Ogni volta che viene chiamata una funzione, le variabili locali dichiarate all'interno della funzione vengono memorizzate sullo stack in un ordine specifico. Quando la chiamata di funzione termina, le variabili locali vengono rimosse dallo stack nell'ordine opposto che sono state archiviate e l'indirizzo di memoria associato alle variabili locali non è più valido. Ciò indica che non è più possibile accedere alla variabile locale utilizzando il puntatore precedentemente utilizzato.
Ragioni dell'avvertimento
Le ragioni per cui questo avvertimento possono verificarsi sono:
1: fuori portata
Se viene utilizzato un puntatore per accedere a una variabile locale dopo che l'indirizzo della variabile locale è andato per portata, IL "Indirizzo dello stack associato alla variabile locale restituita"Verrà lanciato. Ciò potrebbe accadere se il puntatore utilizzato per accedere alla variabile locale non è gestito correttamente o se la funzione viene uscita prima che venga utilizzato il puntatore. Per risolvere questo problema, il puntatore deve prima essere verificato per assicurarsi che sia valido. Una volta confermato che il puntatore è valido, il puntatore deve essere gestito correttamente. Se il puntatore non viene gestito correttamente, il avvertimento persisterà.
Infine, è importante notare che il "Indirizzo dello stack associato alla variabile locale restituita"Può anche essere causato da altri avvertimenti, come un overflow dello stack, in cui lo stack è pieno di più variabili di quante ne possa contenere. Se si verifica un overflow dello stack, è importante risolvere il problema sottostante che ha fatto traboccare lo stack per garantire il "Indirizzo dello stack associato alla variabile locale restituita"Non viene lanciato.
Guarda questo esempio:
#includere
char* getstring ()
Char S [100];
printf ("Immettere una stringa:");
scanf ("%s", s);
ritorna;
int main ()
char* s = getString ();
printf ("hai inserito: %s \ n", s);
restituzione 0;
IL getString () Il metodo crea un array locale str Nello stack in questo esempio e usa scanf () per leggere una stringa dall'utente.La funzione restituisce quindi un puntatore a questo STR variabile locale. Il puntatore restituito è assegnato S nel principale() metodo ed è stampato usando printf (). Tuttavia, da allora str è una variabile locale sullo stack e la sua memoria non è più utilizzabile quando il gettring () Il metodo esce, questo porterà a un comportamento indefinibile.
Produzione
Possiamo usare Malloc () o un metodo simile per allocare dinamicamente la memoria per la stringa e restituire un riferimento a questa memoria appena creata per impedirlo avvertimento e il comportamento non definito. Ecco un'illustrazione di come modificare il codice precedente per sbarazzarsi del avvertimento:
#includere
#includere
char* getstring ()
char * s = malloc (100 * sizeof (char));
printf ("Immettere una stringa:");
scanf ("%s", s);
ritorna;
int main ()
char* s = getString ();
printf ("hai inserito: %s \ n", s);
libero (s);
restituzione 0;
Nel codice sopra aggiornato, allochiamo dinamicamente 100 byte di memoria per la stringa usando Malloc () e restituire un riferimento a questa memoria. Una volta che abbiamo utilizzato la memoria, chiamiamo gratuito() per rilasciarlo. Eliminiamo l'avvertimento e garantiamo che la RAM che stiamo utilizzando sia valida per la durata della nostra applicazione facendo questo.
Produzione
2: Dichiarazione errata delle variabili locali
Oltre a garantire che il puntatore sia gestito correttamente, è anche importante assicurarsi che il Le variabili locali sono dichiarate correttamente. Se le variabili sono dichiarate nell'ordine sbagliato o se le variabili vengono dichiarate al momento sbagliato, può verificarsi l'avvertimento. Ad esempio, se la variabile locale viene dichiarata al termine della funzione, l'indirizzo della variabile locale non sarà più valido.
#includere
int* aggiungi (int a, int b)
int sum = a + b;
restituire ∑
int main ()
int* indirizzo = add (5, 6);
Il compilatore impedisce alla funzione di restituire l'indirizzo del somma Da somma è stato definito e inizializzato all'interno del blocco funzione, rendendolo una variabile locale (utilizzando l'operatore & operatore). Tutte le variabili locali vengono eliminate immediatamente quando la funzione esce, quindi l'istruzione di ritorno non dovrebbe restituire un puntatore che includa la posizione di una variabile locale (somma). In caso contrario, il tuo puntatore indicherà una parte della memoria su cui non hai più il controllo.
Produzione
L'indirizzo di ritorno è di una variabile locale, che è un problema.La correzione è passare l'indirizzo come parametro alla funzione e allocare dinamicamente la memoria a una variabile per tenerla. La variabile non è più una variabile locale perché è stata definita al di fuori del blocco funzione.
Vedi il codice qui:
#includere
#includere
int* aggiungi (int a, int b, int* somma)
*sum = a + b;
Somma di ritorno;
int main ()
int* sum = malloc (sizeof (int));
Aggiungi (5, 6, somma);
printf ("La somma %d è memorizzata all'indirizzo %p \ n", *somma, (void *) somma);
libero (somma);
restituzione 0;
Il codice sopra utilizza il file Malloc () funzione per allocare la memoria per un numero intero e il aggiungere() La funzione riceve un riferimento a questa memoria come parametro di somma. La funzione si moltiplica UN E B, Risparmia il risultato nella memoria di cui alla somma, quindi restituisce la somma. Segnaliamo il valore e la posizione del numero intero citato per somma in principale(). Per fermare le perdite di memoria, quindi usiamo gratuito() per rilasciare la memoria assegnata a Malloc.
Produzione
Conclusione
IL "Indirizzo dello stack associato alla variabile locale restituita"È un avvertimento che può verificarsi quando viene utilizzato un puntatore a una variabile locale dopo che l'indirizzo della variabile locale è uscito dall'ambito. Per evitare che si verifichino questo avvertimento, la gestione adeguata del puntatore e le dichiarazioni variabili locali sono entrambi importanti. È anche fondamentale confermare che nessun altro avvertimento sta causando un overflow dello stack. Seguendo queste linee guida, il "Indirizzo dello stack associato alla variabile locale restituita" può essere evitato.