Phenquestions
Ci vuole un po' di tempo per creare un oggetto. È necessario del 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 di durata e durata della conservazione sono simili; ma la durata si vede più dal punto di vista del luogo 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 una conoscenza di base di C++ per capire questo articolo. Dovresti anche avere conoscenze nell'ambito del C++.
Contenuto dell'articolo
- Illustrazione della durata dell'oggetto
- Durata di conservazione
- Durata della memorizzazione automatica
- Durata di archiviazione dinamica
- Durata di archiviazione statica
- Durata di archiviazione del thread
- Conclusione
Illustrazione della durata dell'oggetto
Considera il seguente programma:
#includereusando lo spazio dei nomi std;
intero principale()
se (1 == 1)
intero x;
x = 1;
char y;
y = 'A';
cout << x << y << '\n';
restituisce 0;
L'uscita è, 1A .
La vita di un oggetto finisce quando esce dal campo di applicazione. La durata dell'oggetto x, inizia da "x = 1;" e termina alla fine di if-local-scope. La durata dell'oggetto y inizia da “y = 'A';” e termina alla fine di if-local-scope. Prima che entrambi gli oggetti muoiano, vengono impiegati nell'istruzione cout .
Durata di conservazione
La durata della conservazione è determinata da uno dei seguenti schemi: durata della conservazione automatica; durata della memorizzazione dinamica; durata della conservazione statica; durata della memorizzazione del thread. Le categorie di durata della conservazione si applicano anche ai riferimenti.
Durata della memorizzazione automatica
Se una variabile non è dichiarata esplicitamente come static, thread_local o extern, allora quella variabile ha una durata di memorizzazione automatica. Gli esempi sono xey sopra. La durata di tali variabili termina quando escono dall'ambito. Il seguente programma illustra la durata della memorizzazione automatica per un riferimento e un puntatore, nell'ambito globale.
#includereusando lo spazio dei nomi std;
intero x = 1;
int& m = x;
carattere y = 'A';
carattere* n = &y;
intero principale()
cout << m << *n << '\n';
restituisce 0;
L'uscita è, 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, possono essere eseguiti più programmi contemporaneamente. Ogni programma ha la sua porzione di memoria. Il resto della memoria che non viene utilizzato da alcun programma è noto come free store. La seguente espressione viene utilizzata per restituire una posizione per un numero intero dal negozio gratuito
nuovo intQuesta posizione (memoria) per l'intero, restituito, deve ancora essere identificata mediante assegnazione a un puntatore. Il codice seguente illustra come utilizzare il puntatore con l'archivio gratuito:
int *ptrInt = nuovo int;*ptrInt = 12;
cout<< *ptrInt <<'\n';
L'uscita è 12 .
Per porre fine alla vita dell'oggetto, utilizzare l'espressione delete come segue:
elimina ptrInt;L'argomento per l'espressione delete è un puntatore. Il codice seguente ne illustra l'utilizzo:
int *ptrInt = nuovo int;*ptrInt = 12;
elimina ptrInt;
Un puntatore creato con la nuova espressione ed eliminato con l'espressione di eliminazione ha una durata di memorizzazione dinamica. Questo puntatore muore quando esce dall'ambito o viene eliminato. La durata dell'oggetto nel codice precedente, inizia da “*ptrInt = 12;” e termina alla fine della regione dichiarativa (scope). C'è di più nelle espressioni nuove e cancellate di quanto discusso qui - vedi più avanti.
Durata di archiviazione statica
Oggetto statico
Un oggetto dichiarato statico, si comporta come l'oggetto ordinario, tranne che la sua durata di memorizzazione, inizia da quando viene inizializzato fino alla fine del programma. Non può essere visto al di fuori del suo scopo, ma può essere indirettamente impiegato al di fuori del suo scopo.
Considera il seguente programma, che dovrebbe contare da 1 a 5 (non testare il programma):
#includereusando lo spazio dei nomi std;
int fn()
int stc = 1;
cout << " << stc;
punto = punto + 1;
se (stc > 5)
restituisce 0;
fn();
intero principale()
fn();
restituisce 0;
L'output è 1 1 1 1 1 1 1 1... e non finisce mai davvero. La definizione della funzione è una funzione ricorrente; il che significa che continua a chiamarsi fino a quando non viene soddisfatta una condizione.
La soluzione è rendere statico l'oggetto stc. Una volta che un oggetto statico è stato inizializzato, il suo valore non può essere modificato, fino al termine del programma. Il seguente programma (che puoi testare), che è lo stesso del precedente, ma ora con stc reso statico, conta da 1 a 5:
#includereusando lo spazio dei nomi std;
int fn()
statico int stc = 1;
cout << " << stc;
punto = punto + 1;
se (stc > 5)
restituisce 0;
fn();
intero principale()
fn();
restituisce 0;
L'uscita è: 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 utilizzato indirettamente, da un ambito diverso. Una volta che un oggetto statico è stato inizializzato, 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 chiamato. La volta successiva che viene chiamato, viene incrementato di “stc = stc + 1;”.
Membro dati statici
Un insieme di variabili e funzioni correlate può essere inserito in un'unità generalizzata chiamata classe. Se alle variabili vengono dati valori particolari, la classe diventa un oggetto. Tuttavia, un oggetto non viene creato semplicemente assegnando valori alla variabile. La classe viene istanziata per ottenere un oggetto; e ogni oggetto creato ha il suo 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 main():
#includereusando lo spazio dei nomi std;
classe TheCla
pubblico:
numero int;
void func (char cha, const char *str)
cout << "There are " << num << " books worth " << cha << str << " in the store." << '\n';
;
intero principale()
TheCla obj;
obj.numero = 12;
obj.func('$', "500");
restituisce 0;
L'uscita è:
Ci sono 12 libri del valore di $ 500 nel negozio.
Si noti che per assegnare il valore 12 alla variabile num, l'oggetto deve essere istanziato, prima che l'assegnazione possa avvenire. È possibile per il programmatore assegnare il valore senza istanziare (creare) un oggetto. Per ottenere ciò, la variabile num dovrà essere dichiarata come statica. Quindi si accederà come "TheCla::num" senza il nome dell'oggetto, ma con il nome della classe. Il seguente programma lo illustra:
#includereusando lo 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 << " in the store." << '\n';
;
intero principale()
cout << TheCla::num << '\n';
TheCla obj;
obj.func('$', "500");
restituisce 0;
L'uscita è:
12
Ci sono 12 libri del valore di $ 500 nel negozio.
Si noti che per accedere al membro dati, num in main(), è stato necessario utilizzare l'operatore di risoluzione dell'ambito :: ::. Inoltre non che la variabile, num dovesse essere resa costante e inizializzata nella descrizione della classe (definizione).
Funzione membro statico
Si noti che nel precedente elenco di programmi sopra, per utilizzare la funzione func in main(), è stato necessario istanziare un oggetto. È possibile per il programmatore chiamare la funzione senza istanziare (creare) un oggetto. Per ottenere ciò, la definizione della funzione deve essere preceduta dalla parola "statico". Quindi si accederà come "TheCla::func()" senza il nome dell'oggetto, ma con il nome della classe. Il seguente programma illustra questo per il membro di dati statici e la funzione membro statico:
#includereusando lo spazio dei nomi std;
classe TheCla
pubblico:
statico const int num = 12;
static void func (char cha, const char *str)
cout << "There are " << num << " books worth " << cha << str << " in the store." << '\n';
;
intero principale()
TheCla::func('$', "500");
restituisce 0;
L'uscita è:
Ci sono 12 libri del valore di $ 500 nel negozio.
Durata di archiviazione del thread
Thread come funzionalità in C++, non è ancora stato implementato dal compilatore g++. Quindi, invece di spiegarlo, la citazione dalla specifica C++ è data come segue:
- Tutte le variabili dichiarate con la parola chiave thread_local hanno una durata di memorizzazione del thread. L'archiviazione per queste entità durerà per la durata del thread in cui vengono create. Esiste un oggetto o riferimento distinto per thread e l'uso del nome dichiarato si riferisce all'entità associata al thread corrente.
- Una variabile con durata di memorizzazione del thread deve essere inizializzata prima del suo primo utilizzo di odr e, se costruita, deve essere distrutta all'uscita dal thread."
Conclusione
La durata di un oggetto inizia quando la sua inizializzazione è completa e termina quando la sua memoria viene rilasciata. La durata dell'archiviazione dinamica inizia quando l'archiviazione creata da (nuovo tipo) viene inizializzata e termina quando l'oggetto esce dall'ambito o viene eliminato da "cancella puntatore". La durata di un oggetto statico inizia quando l'oggetto è stato inizializzato e termina alla fine del programma. Una volta che un oggetto statico è stato inizializzato, il suo valore iniziale non può essere modificato, anche se la sua definizione viene rivalutata. È possibile accedere ai membri dei dati statici e ai membri delle funzioni statiche al di fuori della descrizione della classe con "ClassName::name".
cris
