Classe di archiviazione in C ++ definisce la durata e la visibilità della variabile / funzioni. Lifetime è la durata fino alla quale la variabile rimane attiva e la visibilità è l'accessibilità di una variabile da diversi moduli del programma. Questo aiuta a tracciare l'esistenza di una particolare variabile durante il runtime di un programma. In questo blog sulle classi di archiviazione, esamineremo le varie classi di archiviazione utilizzate in C ++.
Cominciamo.
Cos'è la classe di archiviazione in C ++?
Ogni variabile in C ++ ha un tipo di dati e una classe di archiviazione. Il tipo di dati specifica il tipo di dati che possono essere memorizzati in una variabile come int, float, char ecc. La classe di archiviazione controlla due diverse proprietà di una variabile: durata e ambito.
Avresti visto che ogni variabile ha un tipo di dati, ma potresti non aver visto nessuna classe di archiviazione collegata a una variabile finora. In realtà, se non si definisce una classe di archiviazione, il compilatore le assegna automaticamente una classe di archiviazione predefinita. La classe di archiviazione di una variabile fornisce informazioni sulla posizione di archiviazione della variabile in memoria, il valore iniziale predefinito, l'ambito della variabile e la sua durata.
Tipi di classe di archiviazione
Esistono cinque classi di archiviazione in un programma C ++:
- auto
- Registrati
- statico
- esterno
- mutevole
Discutiamo in dettaglio ciascuna delle classi di archiviazione.
Classe di archiviazione automatica
La classe di archiviazione automatica (automatica) è la classe di archiviazione predefinita per tutte le variabili locali, dichiarate all'interno di una funzione o di un blocco. La parola chiave auto viene utilizzata raramente durante la scrittura di un file Programma C ++ .
L'ambito delle variabili auto è all'interno della funzione o del blocco in cui sono state dichiarate e non è possibile accedervi al di fuori di tale funzione o blocco. È inoltre possibile accedervi all'interno di blocchi annidati all'interno del blocco / funzione genitore in cui è stata dichiarata la variabile auto.
È possibile accedere alle variabili automatiche al di fuori del loro ambito utilizzando una variabile puntatore. È necessario puntare alla stessa posizione di memoria in cui risiedono le variabili.
La sua durata è la stessa della durata della funzione. Una volta terminata l'esecuzione di una funzione, la variabile viene distrutta.
Per impostazione predefinita, durante la dichiarazione viene assegnato loro un valore di spazzatura.
Sintassi:
tipo di dati var_name1 [= value]
o
tipo di dati automatico var_name1 [= value]
Nell'esempio precedente, due variabili sono definite con la stessa classe di archiviazione. Auto può essere utilizzato solo per definire variabili locali, ad esempio all'interno di funzioni.
Registra classe di archiviazione
Come suggerisce il nome, la classe di archiviazione del registro viene utilizzata per dichiarare le variabili di registro. Tutte le funzionalizzazioni della variabile di registro sono le stesse della variabile auto tranne che il compilatore cerca di memorizzare queste variabili nel registro del microprocessore se è disponibile un registro libero. Se non è disponibile un registro libero, questi vengono salvati solo in memoria.
Pertanto, le operazioni sulle variabili di registro sono molto più veloci di quelle di altre variabili che vengono archiviate nella memoria durante il runtime del programma.
Generalmente, poche variabili a cui è necessario accedere frequentemente in un programma vengono dichiarate all'interno della classe di memorizzazione del registro per migliorare il tempo di esecuzione del programma. L'indirizzo di una variabile di registro non può essere ottenuto utilizzando i puntatori.
La dimensione massima della variabile è uguale alla dimensione del registro (cioè una parola circa). Non può essere applicato un operatore unario '&' poiché non ha una posizione di memoria.
Sintassi:
registra il tipo di dati var_name1 [= value]
Esempio:
c ++ ordinamento array in ordine crescente
{register int pi}La definizione di 'registro' non significa che la variabile verrà memorizzata in un registro. Potrebbe essere memorizzato in un registro a seconda dell'hardware e delle limitazioni di implementazione.
Diamo un'occhiata a un esempio di corsi di registrazione e archiviazione automatica.
Esempio:
#include using namespace std // dichiarando la variabile che deve essere resa extern // un valore iniziale può anche essere inizializzato su x int x void autoStorageClass () {printf ('nDemonstrating auto classnn') // dichiarando una variabile auto (semplicemente // funziona anche la scrittura di 'int a = 32') int num = 32 // stampa della variabile auto 'a' printf ('Valore della variabile' num '' 'dichiarata come auto:% dn', num) printf ( '--------------------------------')} void registerStorageClass () {printf ('nDemonstrating register classnn') / / dichiarazione di una variabile di registro register char c = 'G' // stampa della variabile di registro 'b' printf ('Valore della variabile' c '' 'dichiarata come registro:% dn', c) printf ('---- ---------------------------- ')} int main () {// Per dimostrare la classe di archiviazione automatica autoStorageClass () // Per dimostrare register Classe di archiviazione registerStorageClass () return 0}Produzione:
Classe di archiviazione statica
La classe di archiviazione statica viene utilizzata per dichiarare variabili statiche . Le variabili statiche conservano il loro valore (cioè l'ultimo valore) anche quando sono fuori dal loro ambito. Le variabili statiche vengono inizializzate solo una volta &esistono fino alla fine del programma.
La memoria viene allocata solo una volta alla variabile statica e nessuna nuova memoria viene allocata perché non vengono nuovamente dichiarate. È possibile accedere alle variabili statiche globali ovunque nel programma. Per impostazione predefinita, viene assegnato loro il valore 0 dal compilatore.
In C ++, quando static viene utilizzato su un membro dei dati di una classe, viene condivisa solo una copia di tale membro da tutti gli oggetti della sua classe.
Sintassi:
tipo di dati statico var_name1 [= value]
Esempio:
#include void function (void) static int c = 5 // Variabile statica globale main () {while (c--) {function ()} return 0} void function (void) {static int cnt = 2 cnt ++ std :: cout<< 'cnt is ' << cnt std::cout << ' and c is ' << c << std::endl } Produzione:
Classe di archiviazione esterna
La classe di archiviazione esterna è richiesta quando le variabili devono essere condivise tra più file. Le variabili esterne hanno ambito globale e queste variabili sono visibili all'esterno del file in cui sono dichiarate. La variabile extern è visibile a tutti i programmi. Viene utilizzato se due o più file condividono la stessa variabile o funzione.
La durata delle variabili esterne è fintanto che il programma in cui è dichiarata è terminato. Una normale variabile globale può essere resa anche extern inserendo la parola chiave 'extern' prima della sua dichiarazione / definizione in qualsiasi funzione / blocco.
java come creare un array di oggetti
Quando si utilizza 'extern', la variabile non può essere inizializzata poiché tutto ciò che fa è puntare il nome della variabile in una posizione di archiviazione che è stata definita in precedenza.
Sintassi
tipo di dati esterno var_name1
Esempio
#include int cnt extern void write_extern () main () {cnt = 5 write_extern ()}Secondo file: support.cpp
#include extern int cnt void write_extern (void) {std :: cout<< 'Count is ' << cnt << std::endl } Qui, la parola chiave extern viene utilizzata per dichiarare cnt in un altro file. Ora compila questi due file come segue e meno
$ g ++ main.cpp support.cpp -o scrivere
Questo produrrà un programma eseguibile di scrittura, prova a eseguire la scrittura e controlla il risultato come segue & meno
$. / scrivi
5
Andando avanti con la classe di archiviazione in C ++, diamo un'occhiata all'ultima, ovvero la classe di archiviazione mutabile.
Classe di archiviazione mutevole
L'identificatore modificabile si applica solo agli oggetti classe, che consente a un membro di un oggetto di sovrascrivere la funzione membro const. Ovvero, un membro mutabile può essere modificato da una funzione membro const.
Infine, diamo un'occhiata alla tabella di confronto per comprendere le differenze tra le diverse classi di archiviazione.
Classe di archiviazione | Parola chiave | Tutta la vita | Visibilità | Valore iniziale |
Automatico | auto | Blocco funzione | Locale | Spazzatura |
Esterno | esterno | Intero programma | Globale | Zero |
Statico | statico | Intero programma | Locale | Zero |
Registrati | Registrati | Blocco funzione | Locale | Spazzatura |
Mutevole | mutevole | Classe | Locale | Spazzatura |
Ora, dopo aver esaminato i programmi C ++ sopra, avresti capito quali sono le diverse classi di archiviazione in C ++ e come implementarle. Spero che questo blog sia informativo e un valore aggiunto per te.
Quindi siamo giunti alla fine di questo articolo sulle 'classi di archiviazione in C ++'.
come avviare aws cli
Se desideri saperne di più, dai un'occhiata al da Edureka, una società di apprendimento online affidabile. Il corso di formazione e certificazione Java J2EE e SOA di Edureka è progettato per formarti sia sui concetti di base che avanzati su Java insieme a vari framework Java come Hibernate e Spring.
Hai domande per noi? Per favore, menzionalo nella sezione commenti di questo blog e ti risponderemo il prima possibile.