Durata della vita e dell'archiviazione degli oggetti in C ++
È necessario un po 'di tempo per creare un oggetto. È necessario un po 'di tempo per uccidere un oggetto. Quando si parla di un oggetto, sono coinvolte due cose: la posizione che è l'archiviazione e il valore. Il significato della durata della vita e dello stoccaggio è simile; Ma la durata è vista più dal punto di vista della posizione che dal punto di vista del valore. La durata dell'archiviazione è il tempo da quando una posizione è associata a un oggetto al momento in cui la posizione è dissociata dall'oggetto.
Il resto di questo articolo illustra la durata dell'oggetto e spiega brevemente le diverse durate di archiviazione. Dovresti avere conoscenze di base in C ++ per capire questo articolo. Dovresti anche avere conoscenza nell'ambito C ++.
Contenuto dell'articolo
- Illustrazione della vita degli oggetti
- Durata di archiviazione
- Durata automatica di archiviazione
- Durata di archiviazione dinamica
- Durata di conservazione statica
- Durata di archiviazione della discussione
- Conclusione
Illustrazione della vita degli oggetti
Considera il seguente programma:
#includere
Utilizzo dello spazio dei nomi std;
int main ()
if (1 == 1)
int x;
x = 1;
Char y;
y = 'a';
cout << x << y << '\n';
restituzione 0;
L'output è, 1a .
La vita di un oggetto giunge al termine, quando esce dall'ambito. La vita dell'oggetto X, inizia a "x = 1;" e termina alla fine della scusa IF-Local. La vita dell'oggetto y, inizia a "y = 'a';" e termina alla fine della scusa IF-Local. Prima di morire entrambi gli oggetti, sono impiegati nella dichiarazione Cout .
Durata di archiviazione
La durata di archiviazione è determinata da uno dei seguenti schemi: durata automatica di archiviazione; durata di archiviazione dinamica; durata della conservazione statica; Durata di archiviazione della discussione. Categorie di durata di archiviazione, si applicano anche ai riferimenti.
Durata automatica di archiviazione
Se una variabile, non viene dichiarata esplicitamente come statica, thread_local o esterna, quella variabile ha una durata di archiviazione automatica. Esempi sono xey sopra. La durata di tali variabili termina quando usciscono dall'ambito. Il seguente programma illustra la durata automatica dell'archiviazione per un riferimento e un puntatore, nell'ambito globale.
#includere
Utilizzo dello spazio dei nomi std;
int x = 1;
int & m = x;
char y = 'a';
char* n = & y;
int main ()
cout << m << *n << '\n';
restituzione 0;
L'output è, 1a .
La durata di M parte da "int & m = x;" e termina alla fine del programma. La durata di n parte da "char* n = & y;" e termina alla fine del programma.
Durata di archiviazione dinamica
Negozio gratuito
In un computer moderno, più di un programma può essere eseguito contemporaneamente. Ogni programma ha la sua parte di memoria. Il resto della memoria che non viene utilizzato da nessun programma, è noto come Store gratuito. La seguente espressione viene utilizzata per restituire una posizione per un numero intero dal negozio gratuito
Nuovo int
Questa posizione (archiviazione) per l'intero, restituito, deve ancora essere identificata per assegnazione a un puntatore. Il seguente codice illustra come utilizzare il puntatore con il negozio gratuito:
int *ptrint = new int;
*ptrint = 12;
cout<< *ptrInt <<'\n';
L'output è 12 .
Per porre fine alla vita dell'oggetto, usa l'espressione di eliminazione come segue:
Elimina ptrint;
L'argomento per l'espressione elimina è un puntatore. Il seguente codice illustra il suo uso:
int *ptrint = new int;
*ptrint = 12;
Elimina ptrint;
Un puntatore creato con la nuova espressione ed eliminato con l'espressione di eliminazione, è di durata di archiviazione dinamica. Questo puntatore muore mentre va fuori di portata o viene eliminato. La durata dell'oggetto nel codice precedente, inizia da "*ptrint = 12;" e termina alla fine della regione dichiarativa (portata). C'è di più nelle espressioni nuove ed eliminate di quanto non sia stata discussa qui - vedi più tardi.
Durata di conservazione statica
Oggetto statico
Un oggetto dichiarato statico, si comporta come l'oggetto ordinario, tranne per il fatto che la sua durata di archiviazione, inizia da quando viene inizializzato fino alla fine del programma. Non può essere visto al di fuori del suo ambito, ma può essere indirettamente impiegato dall'esterno del suo ambito.
Considera il seguente programma, che dovrebbe contare da 1 a 5 (non testare il programma):
#includere
Utilizzo dello spazio dei nomi std;
int fn ()
int stc = 1;
cout << " << stc;
STC = STC + 1;
if (STC> 5)
restituzione 0;
fn ();
int main ()
fn ();
restituzione 0;
L'uscita è 1 1 1 1 1 1 1 1 1 ... e non finisce mai veramente. La definizione della funzione è una funzione ricorrente; Significa che continua a chiamarsi fino a quando non viene soddisfatta una condizione.
La soluzione è rendere statica l'oggetto STC. Una volta che un oggetto statico è stato inizializzato, il suo valore non può essere modificato, fino alla fine del programma. Il seguente programma (che puoi testare), che è uguale a quanto sopra, ma ora con STC fatto statico, conta da 1 a 5:
#includere
Utilizzo dello spazio dei nomi std;
int fn ()
static int stc = 1;
cout << " << stc;
STC = STC + 1;
if (STC> 5)
restituzione 0;
fn ();
int main ()
fn ();
restituzione 0;
L'output è: 1 2 3 4 5 .
Nota: la durata di un oggetto statico inizia quando l'oggetto è stato inizializzato e termina alla fine del programma. Nel frattempo, l'oggetto può essere usato indirettamente, da un ambito diverso. Una volta inizializzato un oggetto statico, il suo valore iniziale non può essere modificato, anche se la sua definizione viene rivalutata. Nel codice sopra, STC non viene ripristinato, la prossima volta che viene chiamata. La prossima volta che viene chiamato, è incrementato da "STC = STC + 1;".
Membro dei dati statici
Un insieme di variabili e funzionalità correlate può essere inserita in un'unità generalizzata chiamata classe. Se alle variabili vengono forniti valori particolari, la classe diventa un oggetto. Tuttavia, un oggetto non viene creato semplicemente assegnando i valori alla variabile. La classe è istanziata per ottenere un oggetto; e ogni oggetto creato ha il proprio nome diverso dagli altri oggetti della stessa classe. Il seguente programma mostra una classe, chiamata Thecla e un oggetto, chiamato OBJ; Mostra anche come l'oggetto viene istanziato e utilizzato nella funzione principale ():
#includere
Utilizzo dello spazio dei nomi std;
Classe thecla
pubblico:
int num;
void func (char cha, const char *str)
cout << "There are " <<
Num << " books worth " <<
Cha << str << " in the store." << '\n';
;
int main ()
Thecla obj;
obj.num = 12;
obj.func ('$', "500");
restituzione 0;
L'output è:
Ci sono 12 libri per un valore di $ 500 nel negozio.Si noti che per assegnare il valore di 12 al numero variabile, l'oggetto deve essere istanziato, prima che l'assegnazione possa aver luogo. È possibile che il programmatore assegnino il valore senza istanziazione (creazione) un oggetto. Per raggiungere questo obiettivo, la variabile, NUM dovrà essere dichiarata statica. Allora sarà accessibile come "Thecla :: num" senza il nome dell'oggetto, ma con il nome della classe. Il seguente programma illustra questo:
#includere
Utilizzo dello spazio dei nomi std;
Classe thecla
pubblico:
statico const int num = 12;
void func (char cha, const char *str)
cout << "There are " << num <<
"Books Worth" << cha << str <<
" nel negozio." << '\n';
;
int main ()
cout << TheCla::num << '\n';
Thecla obj;
obj.func ('$', "500");
restituzione 0;
L'output è:
12Ci sono 12 libri per un valore di $ 500 nel negozio.
Si noti che per accedere all'elemento dati, num in main (), l'operatore di risoluzione dell'ambito, :: doveva essere utilizzato. Inoltre, la variabile, NUM doveva essere resa costante e inizializzata nella descrizione della classe (definizione).
Funzione membro statica
Si noti che nel precedente elenco del programma sopra, per utilizzare la funzione func in main (), un oggetto doveva essere istanziato. È possibile che il programmatore chiama la funzione senza istanziazione (creazione) un oggetto. Per raggiungere questo obiettivo, la definizione della funzione deve essere preceduta con la parola "statico". Allora sarà accessibile come "TheCla :: Func ()" senza il nome dell'oggetto, ma con il nome della classe. Il seguente programma lo illustra per i dati statici e la funzione dei membri statici:
#includere
Utilizzo dello spazio dei nomi std;
Classe thecla
pubblico:
statico const int num = 12;
statico void func (char cha, const char *str)
cout << "There are " << num <<
"Books Worth" << cha << str <<
" nel negozio." << '\n';
;
int main ()
Thecla :: func ('$', "500");
restituzione 0;
L'output è:
Ci sono 12 libri per un valore di $ 500 nel negozio.Durata di archiviazione della discussione
Discussione come funzionalità in C ++, non è stato ancora implementato dal compilatore G ++. Quindi, invece di spiegare questo, la citazione della specifica C ++ è data come segue:
- Tutte le variabili dichiarate con la parola chiave thread_local hanno una durata di archiviazione thread. Lo spazio di archiviazione per queste entità durerà per la durata del thread in cui vengono create. Esiste un oggetto o un riferimento distinto per thread e l'uso del nome dichiarato si riferisce all'entità associata al thread corrente.
- Una variabile con la durata di archiviazione del thread deve essere inizializzata prima del suo primo utilizzo ODR e, se costruito, deve essere distrutta all'uscita del filo."
Conclusione
La durata di un oggetto inizia quando la sua inizializzazione è completa e termina quando viene rilasciata la memoria. La durata dell'archiviazione dinamica inizia quando viene inizializzata l'archiviazione creata da (nuovo tipo) e termina quando l'oggetto esce dall'ambito o viene eliminato da "Elimina puntatore". La durata di un oggetto statico inizia quando l'oggetto è stato inizializzato e termina alla fine del programma. Una volta inizializzato un oggetto statico, il suo valore iniziale non può essere modificato, anche se la sua definizione viene rivalutata. I membri dei dati statici e i membri della funzione statica sono accessibili al di fuori della descrizione della classe con "ClassName :: Nome".