Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revision Previous revision
Next revision
Previous revision
appunti3s:gestione_della_memoria [2018/04/25 07:55]
127.0.0.1 external edit
appunti3s:gestione_della_memoria [2019/07/28 09:41] (current)
profpro
Line 1: Line 1:
 +> Per ;;tornare all'​**indice** ;; degli argomenti clicca qui [[appunti3s:​linguaggio_c|linguaggio C++]]
 +
 ====== Gestione della memoria ====== ====== Gestione della memoria ======
 +
 ===== Introduzione ===== ===== Introduzione =====
 +
 A seconda di come e dove vengono definite, si possono avere diversi tipi di variabili: A seconda di come e dove vengono definite, si possono avere diversi tipi di variabili:
   * variabili globali: definite fuori da ogni funzione (anche dal main) o classe   * variabili globali: definite fuori da ogni funzione (anche dal main) o classe
   * variabili locali (o automatiche):​ definite dentro una funzione (o classe)   * variabili locali (o automatiche):​ definite dentro una funzione (o classe)
-  * variabili statiche: per approfondimento vedere [[appunti3s:​possibili_approfondimenti#​possibili_approfondimenti|static]] +  * variabili statiche: per approfondimento vedere [[appunti3s:​possibili_approfondimenti#​static|static]] 
-  * variabili dinamiche: termine ​improprio ​usato per definire l'​allocazione di memoria run time.+  * variabili dinamiche: termine usato per definire l'​allocazione di memoria ​durante l'​esecuzione (run time)N.B: var. dinamiche **non** è il contrario di var. statiche 
 ===== Risorsa memoria ===== ===== Risorsa memoria =====
 +Un programma contiene istruzioni da eseguire. ​
 Un programma in esecuzione sul sistema operativo viene chiamato //​processo//​. Un programma in esecuzione sul sistema operativo viene chiamato //​processo//​.
-Il file eseguibile, prima dell'​esecuzione,​ viene trasferito dalla memoria di massa alla memoria ​centrale, dove viene chiamato //​immagine//​ del processo. +Il file eseguibile, prima dell'​esecuzione,​ viene trasferito dalla memoria di __massa__ ​alla memoria ​__centrale__, dove viene chiamato //​immagine//​ del processo. 
-Nella memoria centrale il file eseguibile è diviso in sezioni (section): text section, data setion e stack section.+Nella memoria centrale il file eseguibile è diviso in diverse ​sezioni (section): text section, data setion e stack section.
 Il sistema operativo può gestire ogni sezione, dividendola ulteriormente in segmenti (segment) (anche non contigui tra loro). Il sistema operativo può gestire ogni sezione, dividendola ulteriormente in segmenti (segment) (anche non contigui tra loro).
-Tutto ciò è necessario perché un sistema operativo multitasking,​ che esegue più processi contemporaneamente,​ deve poter offrire ad ogni processo le limitate risorse hardware (come la memoria) garantendo anche la sicurezza. È possibile approfondire questi argomenti studiando i sistemi operativi.+Tutto ciò è necessario perché un sistema operativo multitasking,​ che esegue più processi contemporaneamente,​ deve poter offrire ad ogni processo le limitate risorse hardware (come la memoria ​centrale) garantendo anche la sicurezza. È possibile approfondire questi argomenti studiando i sistemi operativi.
  
 {{:​appunti3s:​stack.png?​|}} {{:​appunti3s:​stack.png?​|}}
Line 21: Line 27:
  
 ==== Data segment ==== ==== Data segment ====
-Area che contiene le variabili cosiddette //​[[appunti3s:​programmazione_multifile#​campi_di_visibilita|globali]]//​ e quelle //​[[appunti3s:​possibili_approfondimenti#​possibili_approfondimenti|statiche]]//​ che sono state inizializzate dal programmatore. ​È di dimensione costante nel tempo, ma a differenza del precedente __non__ è di sola lettura, poiché è possibile modificare i valori delle variabili in runtime. Le variabili in quest'​area sono visibili a tutte le funzioni per tutta la durata del programma.+Area che contiene le variabili cosiddette //​[[appunti3s:​programmazione_multifile#​campi_di_visibilita|globali]]//​ e quelle //​[[appunti3s:​possibili_approfondimenti#​possibili_approfondimenti|statiche]]//​ che sono state inizializzate ​esplicitamente ​dal programmatore. ​Questa area è di dimensione costante nel tempo, ma a differenza del precedente __non__ è di sola lettura, poiché è possibile modificare i valori delle variabili in runtime. Le variabili in quest'​area sono visibili a tutte le funzioni per tutta la durata del programma.
  
 ====BBS segment ==== ====BBS segment ====
Line 27: Line 33:
  
 ==== Heap segment ==== ==== Heap segment ====
-{{ :​appunti3s:​heap1.png|}} Significa letteralmente //​mucchio//​. È detta anche //memoria dinamica// perché all'​interno di questa area (di dimensione non fissa) lo spazio viene riservato e liberato //​dinamicamente//,​ in runtime, cioè durante l'​esecuzione. Questo avviene sotto il controllo del programmatore,​ a seconda delle richieste dell'​utente e delle istruzioni presenti nel programma. Per questi compiti il programmatore usa l'​operatore //new// e l'​operatore //delete//.+{{ :​appunti3s:​heap1.png|}} Significa letteralmente //​mucchio//​. È detta anche //memoria dinamica// perché all'​interno di questa area (di dimensione non fissa) lo spazio viene riservato e liberato //​dinamicamente//,​ in runtime, cioè durante l'​esecuzione. Questo avviene sotto il controllo del programmatore,​ a seconda delle richieste dell'​utente e delle istruzioni presenti nel programma. Per questi compiti il programmatore usa l'​operatore //new// e l'​operatore //delete//.  
 +Nel linguaggio C++ questa memoria è riservata e liberata con una gestione manuale (operatore new e operatore delete). 
 +Nel linguaggio JAva l'​operatore delete non esiste.
  
 ==== Stack ==== ==== Stack ====
-{{ :​appunti3s:​heap2.png|}} Significa letteralmente //pila//. Come in una pila, gli elementi che compongono lo stack vengono riservati e liberati in ordine inverso. È detta anche //memoria automatica//​ perché la gestione è automatica, sotto il controllo del sistema operativo. Lo stack contiene le variabili cosiddette //locali// e i //​parametri//​ (come: int i) dichiarati nell'​ambito dell'​esecuzione di una funzione. Le variabili presenti in questa area sono visibili solo alle rispettive funzioni e solo per l'​intervallo di tempo necessario alla funzione. Ogni elemento viene liberato automaticamente al termine della funzione (punto indicato con la parentesi graffa chiusa). ​+{{ :​appunti3s:​heap2.png|}} Significa letteralmente //pila//. Come in una pila, gli elementi che compongono lo stack vengono riservati ​in modo ordinato ​e liberati in ordine inverso. È detta anche //memoria automatica//​ perché la gestione è automatica, sotto il controllo del sistema operativo. Lo stack contiene le variabili cosiddette //locali// e i //​parametri//​ (come: int i) dichiarati nell'​ambito dell'​esecuzione di una funzione. Le variabili presenti in questa area sono visibili solo alle rispettive funzioni e solo per l'​intervallo di tempo necessario alla funzione. Ogni elemento viene liberato automaticamente al termine della funzione (punto indicato con la parentesi graffa chiusa). ​
  
 ==== Confronto delle caratteristiche ==== ==== Confronto delle caratteristiche ====
Line 41: Line 49:
     * quelle locali (allocate nello stack)     * quelle locali (allocate nello stack)
     * quelle dinamiche (allocate con //new// nell'​heap) ​     * quelle dinamiche (allocate con //new// nell'​heap) ​
 +
 ====== Puntatori a... (qualcosa) ====== ====== Puntatori a... (qualcosa) ======
-Prima è necessario ricordare la distinzione tra la cosiddetta memoria automatica e memoria dinamica. +Prima di spiegare i puntatori ​è necessario ricordare la distinzione tra la cosiddetta memoria automatica e memoria dinamica.
-=====Memoria automatica===== +
-Le variabili automatiche (cosiddette locali) sono gestite automaticamente nello //stack// e quando non servono più vengono automaticamente "​distrutte"​. +
-=====Memoria dinamica=====+
  
-Durante l'​esecuzione del programma può essere necessario allocare (riservare) dinamicamente della memoria. Questo accade per le operazioni dove non si possono prevedere in anticipo le richieste di un utente. ​+  * **Memoria automatica** Le variabili automatiche (cosiddette locali) sono gestite automaticamente nello //stack// e quando non servono più vengono automaticamente "​distrutte"​. 
 +  * **Memoria dinamica** ​Durante l'​esecuzione del programma può essere necessario allocare (riservare) dinamicamente della memoria. Questo accade per le operazioni dove non si possono prevedere in anticipo le richieste di un utente. ​
 Per riservare una zona di memoria dinamicamente si usa l'​operatore //new//. Per riservare una zona di memoria dinamicamente si usa l'​operatore //new//.
 +
 ==== New ==== ==== New ====
-L'​operatore //new// fa parte della libreria standard del C++, ma è una delle poche eccezioni ​che non necessità di specificare il namespace std. +L'​operatore //new// fa parte della libreria standard del C++, ma è una delle poche eccezioni ​in cui non è necessario ​specificare il namespace std.  
 + 
 +Esempio del codice necessario per poter usare new 
 <​code>#​include <​new></​code>​ <​code>#​include <​new></​code>​
 +
 <​code>​new float; // riserva la quantità di memoria necessaria per un numero in virgola mobile</​code>​ <​code>​new float; // riserva la quantità di memoria necessaria per un numero in virgola mobile</​code>​
-Cosa restituisce?​ Restituisce l'​indirizzo iniziale della memoria riservata. Dove memorizzare un indirizzo? Quale tipo di dato è utile per memorizzare un indirizzo di memoria?  + 
-Anche se un indirizzo di memoria è un numero, non si usa il tipo //int//, ma un tipo specifico ​chiamato //puntatore a...//. Nel precedente esempio si deve usare un "//​puntatore a float//"​. Per  dichiarare tale puntatore basta aggiungere l'​operatore asterisco * dopo il nome del tipo:+Cosa restituisce ​l'​operatore new? Restituisce l'​indirizzo iniziale della memoria ​che è appena stata riservata. ​ 
 + 
 +Dove memorizzare un indirizzo? Quale tipo di dato è utile per memorizzare un indirizzo di memoria?  
 +Anche se un indirizzo di memoria è un numero, non si usa il tipo //int//, ma un tipo di dato speciale ​chiamato //puntatore a...//. Nel precedente esempio si deve usare un "//​puntatore a float//"​. Per  dichiarare tale puntatore basta aggiungere l'​operatore asterisco * dopo il nome del tipo:
 <​code>​ <​code>​
 float* numero; ​      //​definizione della variabile puntatore a... float* numero; ​      //​definizione della variabile puntatore a...
Line 140: Line 155:
 to do... to do...
  
 +> Per ;;tornare all'​**indice** ;; degli argomenti clicca qui [[appunti3s:​linguaggio_c]]
  • appunti3s/gestione_della_memoria.1524635754.txt.gz
  • Last modified: 2018/04/25 07:55
  • by 127.0.0.1