Qualificatori C ++ e specificatori di classe di archiviazione

CV sta per volatile costante. La dichiarazione di un oggetto che non è preceduto da const e/o volatile è un tipo non qualificato. D'altra parte, la dichiarazione di un oggetto che è preceduto da const e/o volatile è un tipo qualificato CV. Se un oggetto viene dichiarato const, il valore nella sua posizione non può essere modificato. Una variabile volatile è una variabile il cui valore è sotto l'influenza del programmatore e quindi non può essere modificata dal compilatore.Gli specificatori della classe di archiviazione si riferiscono alla vita, al luogo e al modo in cui esiste un tipo. Gli specificatori della classe di archiviazione sono statici, mutabili, thread_local ed esterni.

Questo articolo spiega qualificatori C ++ e specificatori di classe di archiviazione. Pertanto, alcune conoscenze preliminari in C ++ sono utili per apprezzare davvero l'articolo.

Contenuto dell'articolo:

• Qualificatori
• Specificatori di classe di archiviazione
• Conclusione

Qualificatori:

const

Un oggetto dichiarato costante è un oggetto La memoria (posizione) del cui valore non può essere modificato. Ad esempio, nella dichiarazione:

int const theint = 5;

Il valore di 5 nell'archiviazione non può essere modificato.

volatile

Considera la seguente dichiarazione:

int portval = 26904873;

I compilatori a volte interferiscono con il valore di una variabile con la speranza di ottimizzare il programma. Il compilatore può mantenere il valore di una variabile come costante quando non dovrebbe essere costante. I valori degli oggetti che hanno a che fare con le porte IO mappate dalla memoria o le routine di servizio di interruzione dei dispositivi periferici, possono essere interferiti dal compilatore. Per prevenire tale interferenza, rendere la variabile volatile, come:

int volatile Portval;
Portval = 26904873;
o come:
int volatile portval = 26904873;

Combinando const e volatile:

const e volatile può verificarsi in una dichiarazione come segue:

int const volatile portval = 26904873;

qualificanti CV

Una variabile preceduta con const e/o volatile è un tipo qualificato CV. Una variabile non preceduta con const o volatile o entrambi è un tipo non qualificato CV.

Ordine:

Un tipo può essere più qualificato in CV di un altro:

• Nessun qualificatore CV è inferiore a un const qualificatore
• Nessun qualificatore CV è anche meno di un qualificatore volatile
• Nessun qualificatore CV è inferiore a un qualificatore cost-volatile
• Il qualificatore const è inferiore a un qualificatore cost-volatile
• Il qualificatore volatile è inferiore a un qualificatore cost-volatile

Non è stato ancora concluso se const e volatile sono dello stesso rango.

Array e oggetto istanziato:

Quando un array viene dichiarato costante, come nella seguente affermazione, significa che il valore di ciascun elemento dell'array non può essere modificato:

const char arr [] = 'a', 'b', 'c', 'd';

Che si tratti di un "A", "b", "c" o "d", non può ancora essere cambiato in qualche altro valore (carattere).

Una situazione simile si applica a un oggetto istanziato di una classe. Considera il seguente programma:

#includere
Utilizzo dello spazio dei nomi std;
Cla di classe

pubblico:
char ch0 = 'a';
char ch1 = 'b';
char ch2 = 'c';
char ch3 = 'd';
;
int main ()

const cla obj;
restituzione 0;

A causa dell'affermazione "const cla obj;" Con const nella funzione principale (), né 'A' né 'b' né 'c' né 'd' possono essere cambiati in qualche altro valore.

Specificatori di classe di archiviazione:

Gli specificatori della classe di archiviazione sono statici, mutabili, thread_local ed esterni.

IL Specificatore di classe di archiviazione statica

Lo specificatore della classe di archiviazione statica consente alla variabile di vivere dopo che il suo ambito è passato, ma non è possibile accedervi direttamente.

Il seguente programma lo illustra, con una funzione ricorsiva:

#includere
Utilizzo dello spazio dei nomi std;
int funct ()

static int stac = 10;
cout << stac < 50)

cout << '\n';
restituzione 0;

funct ();

int main ()

funct ();
restituzione 0;

L'output è:

10 20 30 40 50

Se una variabile statica non viene inizializzata alla sua prima dichiarazione, assume il valore predefinito per il suo tipo.

L'impianto statico può anche essere utilizzato con i membri di una classe; L'uso qui è diverso. Qui, consente di accedere al membro senza istanza per l'oggetto.

Il seguente programma lo illustra per un membro dei dati:

#includere
Utilizzo dello spazio dei nomi std;
Cla di classe

pubblico:
statico const int num = 8;
;
int main ()

cout << Cla::num << '\n';
restituzione 0;

L'output è:

8

Il membro dei dati statici deve essere costante. Si noti che l'uso dell'operatore di risoluzione dell'ambito per accedere alla variabile statica al di fuori del suo ambito (nella funzione principale).

Il seguente programma illustra l'uso di "statico" per una funzione membro:

#includere
Utilizzo dello spazio dei nomi std;
Cla di classe

pubblico:
Metodo void statico ()

cout << "Of static member function!" << '\n';

;
int main ()

Cla :: Method ();
restituzione 0;

L'output è:

Della funzione membro statico!

Si noti che l'uso dell'operatore di risoluzione dell'ambito per accedere alla funzione dei membri statici al di fuori del suo ambito (nella funzione principale).

L'identificatore mutabile

Ricorda, dall'alto, che se un oggetto istanziato inizia con const, il valore di uno qualsiasi dei suoi normali dati non può essere modificato. E per la modifica di tali membri di dati, deve essere dichiarato, mutabile.

Il seguente programma illustra questo:

#includere
Utilizzo dello spazio dei nomi std;
Cla di classe

pubblico:
char ch0 = 'a';
char ch1 = 'b';
mutabile char ch2 = 'c';
char ch3 = 'd';
;
int main ()

const cla obj;
obj.ch2 = 'z';
cout << obj.ch0 << " << obj.ch1 << " << obj.ch2 << " << obj.ch3 << " << '\n';
restituzione 0;

L'output è:

'a "b" z "d'

Lo specificatore thread_local

Nell'esecuzione normale di un programma, viene eseguito un segmento di codice, quindi il segmento di codice successivo, seguito da un altro segmento di codice dopo, e così via. Questo è un thread; il thread principale. Se due segmenti di codice eseguono contemporaneamente (stessa durata), è necessario un secondo thread. Il risultato del secondo thread potrebbe anche essere pronto prima del thread principale.

La funzione principale () è come il thread principale. Un programma può avere più di due thread per un comportamento così asincrono.

Il secondo thread necessita di un ambito (ambito di blocco) per operare. Questo è in genere fornito dall'ambito della funzione, una funzione. Una variabile in un ambito esterno che può essere visto nell'ambito del secondo thread.

Il seguente programma breve illustra l'uso dello specificatore thread_local:

#includere
#includere
Utilizzo dello spazio dei nomi std;
thread_local int inter = 1;
void thread_function ()

inter = inter + 1;
cout << inter << "nd thread\n";

int main ()

Thread Thr (& Thread_Function); // THR inizia a correre
cout << inter << "st or main thread\n";
thr.giuntura(); // Il thread principale attende il thread, thr per finire
restituzione 0;

L'output è:

1 ° o filo principale
2 ° thread

La variabile, inter, preceduta da thread_local, significa che Inter ha un'istanza separata in ciascun thread. E che può essere modificato in diversi thread per avere valori diversi. In questo programma, viene assegnato il valore, 1 nel thread principale, e modificato nel valore, 2 nel secondo thread.

Un thread necessita di un oggetto speciale per operare. Per questo programma, la libreria inclusa da "#include" ha una classe chiamata thread, da cui è stato istanziato l'oggetto Thr. Il costruttore per questo oggetto prende un riferimento alla funzione thread come argomento. Il nome della funzione thread in questo programma è thread_function ().

La funzione membro join () per l'oggetto speciale, nella sua posizione impiegata, fa attendere che il secondo thread finisca l'esecuzione prima che continui a eseguire, altrimenti la funzione principale () può uscire senza il (secondo) thread che ha ha prodotto il suo risultato.

Lo specificatore esterno

In termini semplici, per una dichiarazione, la memoria non viene allocata per la variabile o la funzione, mentre per una definizione viene assegnata la memoria. La parola riservata esterna consente di dichiarare una variabile o una funzione globale in un file ma definita in un altro. Tali file sono chiamati unità di traduzione per l'applicazione C ++ completa.

Digita il seguente programma e salvalo con il nome file, mainfile:

#includere
Utilizzo dello spazio dei nomi std;
int myint;
const char ch;
void myfn ();
int main ()

myfn ();
restituzione 0;

La variabile, myint, la variabile costante, ch e la funzione, myfn (), sono state dichiarate senza essere definita.

Digita il seguente programma con le definizioni e salvalo con il nome file, altri file, nella stessa directory:

#includere
Utilizzo dello spazio dei nomi std;
int myint = 10;
const char ch = 'c';
void myfn ()

cout << "myFn() says " << myInt << " and " << ch <<'\n';

Prova a compilare l'applicazione sul terminale (prompt del comando DOS) con il comando seguente e nota che potrebbe non compilare:

G ++ Mainfile.CPP Otherfile.CPP -O completo.exe

Ora, precedono le tre dichiarazioni in Mainfile con la parola "esterno", come segue:

esterno int myint;
esterno const char ch;
esterno void myfn ();

Ri-salvare il file main. Compilare l'applicazione con:

G ++ Mainfile.CPP Otherfile.CPP -O completo.exe

(Ecco come i file separati per la stessa applicazione vengono compilati in C ++)

E dovrebbe compilare. Ora, esegui l'applicazione, completa.exe e l'output dovrebbe essere:

myfn () dice 10 e c

Si noti che con l'uso di "esterno", una variabile costante può essere dichiarata in un file ma definita in un altro. Quando si tratta di dichiarazione e definizione della funzione in file diversi, l'uso di est è facoltativo.

Quando utilizzare l'esterno? Usalo quando non si dispone di file di intestazione con dichiarazioni globali.

"Extern" è anche usato con dichiarazioni di modelli - vedi più avanti.

Conclusione:

Una variabile preceduta con const e/o volatile è un tipo qualificato CV. Una variabile, non preceduta con const o volatile o entrambi, è un tipo non qualificato CV.

Gli specificatori della classe di archiviazione sono statici, mutabili, thread_local ed esterni. Questi influenzano la durata della vita (durata), il luogo e il modo di occupazione delle variabili in un'applicazione.