Stack overflow: differenze tra le versioni

Versione delle 23:31, 10 nov 2009

Versione attuale delle 22:54, 22 giu 2025

(45 versioni intermedie di 29 utenti non mostrate)

Riga 1:

{{nota disambigua|il sito di Q&A omonimo|Stack Overflow (sito)|Stack Overflow}}

In [[informatica]] uno '''stack overflow''' avviene quando è in uso una quantità troppo elevata di [[Memoria (informatica)|memoria]] nello [[stack]]. In molti [[linguaggi di programmazione]] lo stack delle chiamate contiene una quantità limitata di memoria, che viene fissata di solito all'avvio del programma. La dimensione dello stack dipende da molteplici fattori, inclusi il linguaggio di programmazione, l'[[Architettura (computer)|architettura]] della macchina, l'uso del [[multithreading]], e la disponibilità di memoria nel sistema. Quando viene usata troppa memoria nello stack si dice che avviene un'[[overflow]], e tipicamente come conseguenza di questa situazione si verifica un [[Crash (informatica)|crash]] del programma<ref name="fortran1"> {{cite web

In [[informatica]], uno '''''stack overflow''''' avviene quando è richiesto l'uso di una quantità troppo elevata di [[Memoria (informatica)|memoria]] nello [[Allocazione dinamica della memoria|''stack'']].

| last = Burley

| first = James Craig

| title = Using and Porting GNU Fortran

| url= http://sunsite.ualberta.ca/Documentation/Gnu/gcc-2.95.2/html_node/g77_597.html

| date = 1991-06-01 }}</ref>. Questa classe di [[bug]] solitamente è causata da uno dei due tipi di errori di programmazione<ref name="devx">

{{cite web

| last = Danny

| first = Kalev

| title = Understanding Stack Overflow

| url=http://www.devx.com/tips/Tip/14276

| date = 2000-09-05 }}</ref>.

In molti [[linguaggi di programmazione]], lo [[Call stack|stack delle chiamate]] contiene una quantità limitata di memoria, fissata di solito all'avvio del programma. La dimensione dello stack dipende da molteplici fattori, inclusi il linguaggio di programmazione, l'[[Architettura (computer)|architettura]] della macchina, l'uso del ''[[multithreading]]'' e la disponibilità di memoria nel sistema. Quando è usata troppa memoria nello ''stack'' si dice che avviene un ''[[Overflow aritmetico|overflow]]'', e si verifica un [[Crash (informatica)|crash]] del programma<ref name="fortran1">{{Cita web|cognome=Burley|nome=James Craig|titolo=Using and Porting GNU Fortran|url=http://sunsite.ualberta.ca/Documentation/Gnu/gcc-2.95.2/html_node/g77_597.html|data=1º giugno 1991|urlmorto=sì|urlarchivio=https://www.webcitation.org/6BBbWyyAU?url=http://sunsite.ualberta.ca/Documentation/Gnu/gcc-2.95.2/html_node/g77_597.html|dataarchivio=5 ottobre 2012}}</ref>. Questa classe di [[bug]] solitamente è causata da uno dei due tipi di errori di programmazione<ref name="devx">{{Cita web|cognome=Danny|nome=Kalev|titolo=Understanding Stack Overflow|url=http://www.devx.com/tips/Tip/14276|data=5 settembre 2000}}</ref>: la ricorsione infinita e l'uso di variabili di stack molto grandi.

==Ricorsione infinita==

La causa più comune di uno stack overflow è la profondità eccessiva o una [[ricorsione]] infinita. I linguaggi che implementano la tecnica [[Algoritmo_ricorsivo#Eliminazione_della_ricorsione|tail recursion]], come ad esempio il linguaggio [[Scheme]], permettono una particolare ricorsione infinita che possa essere eseguita senza stack overflow. Questo avviene poiché le chiamate che fanno uso di tail-recursion non richiedono uno spazio aggiuntivo nello stack<ref name="tailRecur">{{cite web

| title = An Introduction to Scheme and its Implementation

| url=http://www.federated.com/~jim/schintro-v14/schintro_73.html

| date = 1997-02-19 }} </ref>

.

== Ricorsione infinita ==

==Variabili di stack molto grandi==

{{Vedi anche|Loop infinito}}

L'altra causa principale dello stack overflow è il tentativo di allocare più memoria nello stack di quella che è disponibile. Questo avviene tipicamente quando si crea un [[array]] di variabili locali molto grande. Per questo motivo gli array più grandi di qualche [[kilobyte]] dovrebbero essere allocati dinamicamente anziché allocarli come variabili locali<ref name="onlamp">{{cite web

La causa più comune di uno stack overflow è una [[ricorsione]] con profondità eccessiva o infinita.

| last = Feldman

| first = Howard

| title = Modern Memory Management, Part 2

| url=http://www.onlamp.com/pub/a/onlamp/2005/11/23/memory-management-2.html

| date = 2005-11-23 }} </ref>.

I linguaggi che implementano la tecnica [[Algoritmo_ricorsivo#Eliminazione_della_ricorsione|''tail recursion'']], come ad esempio il linguaggio [[Scheme]], permettono una particolare ricorsione infinita che può essere eseguita senza ''stack overflow''. Questo avviene poiché le chiamate che fanno uso di ''tail recursion'' non richiedono uno spazio aggiuntivo nello ''stack''<ref name="tailRecur">{{Cita web|titolo=An Introduction to Scheme and its Implementation|url=http://www.federated.com/~jim/schintro-v14/schintro_73.html|data=19 febbraio 1997|urlmorto=sì|urlarchivio=https://web.archive.org/web/20070810213035/http://www.federated.com/~jim/schintro-v14/schintro_73.html|dataarchivio=10 agosto 2007}}</ref>.

Gli stack overflow sono aggravati da qualsiasi cosa riduca la dimensione effettiva dello stack di un programma. Ad esempio un programma che viene eseguito come [[thread]] singolo potrebbe funzionare correttamente, ma se lo stesso programma viene eseguito con thread multipli si verifica un crash del programma. Ciò avviene perché molti programmi che usano i thread hanno a disposizione uno stack più piccolo per ogni singolo thread rispetto ad un programma che non usi i thread. Allo stesso modo, le persone che si avvicinano allo sviluppo di un [[kernel]] sono invitate a non usare algoritmi ricorsivi e [[buffer]] molto grandi nello stack<ref name="apple1">{{cite web

| publisher= [[Apple Inc]].

| title = Kernel Programming Guide: Performance and Stability Tips

| url=http://developer.apple.com/DOCUMENTATION/Darwin/Conceptual/KernelProgramming/style/chapter_5_section_5.html

| date = 2006-11-07 }} </ref><ref name="xenotime">{{cite web

| last = Dunlap

| first = Randy

| title = Linux Kernel Development: Getting Started

| url=http://www.xenotime.net/linux/mentor/linux-mentoring.pdf

| date = 2005-05-19 }} </ref>.

== Variabili di stack molto grandi ==

==Esempi nel linguaggio C/C++==

L'altra causa principale dello ''stack overflow'' è il tentativo di allocare più memoria di quella disponibile nello stack. Questo avviene quando si crea un [[array]] di [[Variabile (informatica)#Visibilità di una variabile|variabili locali]] molto grande. Per questo motivo gli array più grandi di qualche [[kilobyte]] dovrebbero essere [[Allocazione dinamica della memoria|allocati dinamicamente]] anziché allocarli come variabili locali<ref name="onlamp">{{Cita web|cognome=Feldman|nome=Howard|titolo=Modern Memory Management, Part 2|url=http://www.onlamp.com/pub/a/onlamp/2005/11/23/memory-management-2.html|data=23 novembre 2005|accesso=10 novembre 2009|dataarchivio=20 settembre 2012|urlarchivio=https://web.archive.org/web/20120920112622/http://onlamp.com/pub/a/onlamp/2005/11/23/memory-management-2.html|urlmorto=sì}}</ref>.

== Cause che possono ridurre la dimensione dello stack disponibile e quindi rendere più probabile uno ''stack overflow'' ==

===Ricorsione infinita con una funzione===

Gli ''stack overflow'' sono aggravati da qualsiasi cosa riduca la dimensione effettiva dello ''stack'' di un programma.

<source lang="c">

void f() {

f();

}

int main(void) {

f();

return 0;

}

</source>

Ad esempio un programma eseguito come ''[[Thread (informatica)|thread]]'' singolo potrebbe funzionare correttamente, ma se lo stesso programma è eseguito con ''thread'' multipli si verifica un crash del programma, perché molti programmi che usano i ''thread'' hanno a disposizione uno ''stack'' più piccolo per ogni singolo ''thread'' rispetto a un programma che non usa i ''thread''.

Questo frammento di codice invoca la funzione <code>f()</code>, e la funzione <code>f()</code> a sua volta richiama se stessa, generando in tal modo una ricorsione infinita.

Allo stesso modo, chi studia lo [[sviluppo (informatica)|sviluppo]] di un [[kernel]] è invitato a non usare [[algoritmo ricorsivo|algoritmi ricorsivi]] e [[buffer]] molto grandi nello stack<ref name="apple1">{{Cita web|editore=[[Apple Inc]].|titolo=Kernel Programming Guide: Performance and Stability Tips|url=https://developer.apple.com/DOCUMENTATION/Darwin/Conceptual/KernelProgramming/style/chapter_5_section_5.html|data=7 novembre 2006|urlmorto=sì|urlarchivio=https://web.archive.org/web/20081207013401/http://developer.apple.com/DOCUMENTATION/Darwin/Conceptual/KernelProgramming/style/chapter_5_section_5.html|dataarchivio=7 dicembre 2008}}</ref><ref name="xenotime">{{Cita web|cognome=Dunlap|nome=Randy|titolo=Linux Kernel Development: Getting Started|url=http://www.xenotime.net/linux/mentor/linux-mentoring.pdf|data=19 maggio 2005|urlmorto=sì|urlarchivio=https://web.archive.org/web/20120227142532/http://www.xenotime.net/linux/mentor/linux-mentoring.pdf|dataarchivio=27 febbraio 2012}}</ref>.

===Ricorsione infinita con due funzioni===

<source lang="c">

== Esempi nel linguaggio C/C++ ==

void f(void);

=== Ricorsione infinita con una funzione ===

void g(void);

<syntaxhighlight lang="c" line="1" copy=1>

void f() {

f();

}

int main(void) {

f();

return 0;

}

</syntaxhighlight>

Questo frammento di codice invoca la [[funzione (informatica)|funzione]] <code>f()</code>, e la funzione <code>f()</code> a sua volta richiama se stessa, generando in tal modo una ricorsione infinita.

=== Ricorsione infinita con due funzioni (mutuale) ===

<syntaxhighlight lang="c" line="1" copy=1>

void f(void);

void g(void);

int main(void) {

f();

return 0;

}

intvoid mainf(void) {

fg();

}

return 0;

}

void fg(void) {

gf();

}

</syntaxhighlight>

void g(void) {

f();

}

</source>

La funzione <code>f()</code> e la funzione <code>g()</code> si richiamano continuamente a vicenda, finché non si verifica lo ''stack overflow''.

=== Variabile nello stack eccessivamente grande ===

<sourcesyntaxhighlight lang="c" line="1" copy=1>

int main(void) {

double n[10000000];

return 0;

}

</syntaxhighlight>

</source>

L'array dichiarato in questo frammento di codice richiede più memoria di quella disponibile nello ''stack'', causando così uno ''stack overflow''.

== Note ==

<references />

{{Reflist}}

== Voci correlate ==

* [[Heap overflow]]

* [[Buffer overflow]]

== Collegamenti esterni ==

[[en:Stack overflow]]

* {{FOLDOC||stack overflow}}

[[es:Desbordamiento de pila]]

[[fr:Dépassement de pile]]

{{Portale|informatica}}

[[ja:スタックオーバーフロー]]

[[pl:Przepełnienie stosu]]

[[Categoria:Gestione del software]]

<noinclude>{{Categorizzare|informatica}}</noinclude>

[[Categoria:Terminologia informatica]]