Spécificateurs de qualifications C ++ et de classement

CV signifie constante volatile. La déclaration d'un objet qui n'est pas précédé par const et / ou volatile est un type non cvalifié CV. D'un autre côté, la déclaration d'un objet précédé par const et / ou volatile est un type qualifié CV. Si un objet est déclaré const, la valeur de son emplacement ne peut pas être modifiée. Une variable volatile est une variable dont la valeur est sous l'influence du programmeur, et ne peut donc pas être modifiée par le compilateur.Les spécificateurs de classe de stockage se réfèrent à la vie, au lieu et à la manière dont un type existe. Les spécificateurs de classe de stockage sont statiques, mutables, thread_local et exter.

Cet article explique les qualificateurs C ++ et les spécificateurs de classe de stockage. Ainsi, certaines connaissances préliminaires en C ++ sont utiles pour vraiment apprécier l'article.

Contenu de l'article:

• Qualifications
• Spécificateurs de classe de stockage
• Conclusion

Qualifiants:

const

Un objet déclaré constant est un objet dont le stockage (emplacement) dont la valeur ne peut pas être modifié. Par exemple, dans la déclaration:

int const theint = 5;

La valeur de 5 dans le stockage pour le nombre ne peut pas être modifiée.

volatil

Considérez la déclaration suivante:

int portval = 26904873;

Les compilateurs interfèrent parfois avec la valeur d'une variable dans l'espoir d'optimiser le programme. Le compilateur peut maintenir la valeur d'une variable comme constante lorsqu'elle n'est pas censée être constante. Les valeurs d'objet qui ont à voir avec les ports IO mappés par la mémoire, ou les routines de service d'interruption des dispositifs périphériques, peuvent être interférées par le compilateur. Pour éviter une telle interférence, rendez la variable volatile, comme:

int portval volatil;
Portval = 26904873;
ou comme:
int portval volatile = 26904873;

Combinant const et volatile:

Const et volatiles peuvent se produire dans une déclaration comme suit:

int const volatile portval = 26904873;

quadalinateurs CV

Une variable précédée avec const et / ou volatile est un type qualifié CV. Une variable non précédée avec const ou volatile ou les deux est un type non cvalifié CV.

Commande:

Un type peut être plus qualifié par CV qu'un autre:

• Aucun CV-Qualificateur n'est inférieur à un qualificatif de constance
• Aucun CV-Qualificateur n'est également inférieur à un qualificatif volatil
• Aucun CV-Qualificateur n'est inférieur à un qualificatif de const-volatile
• Const-qualificateur est inférieur à un qualificatif de const-volatile
• La qualification volatile est inférieure à un qualificatif de const-volatile

Il n'a pas encore été conclu si le const et volatile sont du même rang.

Tableau et objet instancié:

Lorsqu'un tableau est déclaré constant, comme dans l'instruction suivante, cela signifie que la valeur de chaque élément du tableau ne peut pas être modifiée:

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

Qu'il s'agisse d'un «A», du «B», du «C» ou du «D», il ne peut toujours pas être changé en une autre valeur (personnage).

Une situation similaire s'applique à un objet instancié d'une classe. Considérez le programme suivant:

#inclure
Utilisation de Namespace Std;
classe CLA

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

Const Cla Obj;
retour 0;

En raison de la déclaration «Const CLA OBJ»; avec const dans la fonction principale (), ni 'a' ni 'b' ni 'c' ni 'd' ne peut être changé en une autre valeur.

Spécificateurs de classe de stockage:

Les spécificateurs de classe de stockage sont statiques, mutables, thread_local et exter.

Le spécificateur de classe de stockage statique

Le spécificateur de classe de stockage statique permet à la variable de vivre une fois que sa portée a traversé, mais il ne peut pas être accessible directement.

Le programme suivant l'illustre, avec une fonction récursive:

#inclure
Utilisation de Namespace Std;
int funct ()

statique int stac = 10;
couter << stac < 50)

couter << '\n';
retour 0;

funct ();

int main()

funct ();
retour 0;

La sortie est:

10 20 30 40 50

Si une variable statique n'est pas initialisée à sa première déclaration, elle assume la valeur par défaut pour son type.

Le spécificateur statique peut également être utilisé avec les membres d'une classe; L'utilisation ici est différente. Ici, il permet au membre d'être accessible sans instanciation pour l'objet.

Le programme suivant l'illustre pour un membre de données:

#inclure
Utilisation de Namespace Std;
classe CLA

public:
const statique int int num = 8;
;
int main()

couter << Cla::num << '\n';
retour 0;

La sortie est:

8

Le membre de données statique doit être constant. Notez que l'utilisation de l'opérateur de résolution de portée pour accéder à la variable statique en dehors de sa portée (dans la fonction principale).

Le programme suivant illustre l'utilisation de «statique» pour une fonction membre:

#inclure
Utilisation de Namespace Std;
classe CLA

public:
Méthode vide statique ()

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

;
int main()

CLA :: Method ();
retour 0;

La sortie est:

De la fonction de membre statique!

Notez que l'utilisation de l'opérateur de résolution de portée pour accéder à la fonction de membre statique en dehors de sa portée (dans la fonction principale).

Le spécificateur mutable

N'oubliez pas, d'en haut, que si un objet instancié commence par const, la valeur de l'un de ses membres de données normaux ne peut être modifié. Et pour que un tel membre de données soit modifié, il doit être déclaré, mutable.

Le programme suivant illustre ceci:

#inclure
Utilisation de Namespace Std;
classe CLA

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

Const Cla Obj;
obj.ch2 = 'z';
couter << obj.ch0 << " << obj.ch1 << " << obj.ch2 << " << obj.ch3 << " << '\n';
retour 0;

La sortie est:

'a "b" z "d'

Le spécificateur thread_local

Dans l'exécution normale d'un programme, un segment de code est exécuté, puis le segment de code suivant, suivi d'un autre segment de code après cela, et ainsi de suite. C'est un fil; le fil principal. Si deux segments de code s'exécutent en même temps (même durée), alors un deuxième thread est nécessaire. Le résultat du deuxième thread peut même être prêt avant le fil principal.

La fonction principale () est comme le thread principal. Un programme peut avoir plus de deux threads pour un comportement aussi asynchrone.

Le deuxième thread a besoin d'une portée (portée du bloc) afin de fonctionner. Ceci est généralement fourni par la portée de la fonction, une fonction. Une variable dans une portée extérieure qui peut être vue dans la portée du deuxième fil.

Le programme court suivant illustre l'utilisation du spécificateur Thread_Local:

#inclure
#inclure
Utilisation de Namespace Std;
thread_local int inter = 1;
void thread_function ()

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

int main()

Thread thr (& thread_function); // thr commence à courir
couter << inter << "st or main thread\n";
thr.rejoindre(); // Le fil principal attend le fil, thr pour terminer
retour 0;

La sortie est:

1er ou fil principal
2ème fil

La variable, inter, précédée de thread_local, signifie qu'Inter a une instance distincte dans chaque thread. Et qu'il peut être modifié dans différents threads pour avoir des valeurs différentes. Dans ce programme, il est attribué la valeur, 1 dans le thread principal, et modifié à la valeur, 2 dans le deuxième thread.

Un thread a besoin d'un objet spécial pour fonctionner. Pour ce programme, la bibliothèque incluse par «#include» a une classe appelée un thread, à partir de laquelle l'objet thr a été instancié. Le constructeur de cet objet prend une référence à la fonction de thread comme un argument. Le nom de la fonction de thread dans ce programme est thread_function ().

La fonction de membre join () pour l'objet spécial, à sa position utilisée, fait attendre le thread principal que le deuxième thread finit de s'exécuter avant de continuer à exécuter, sinon, la fonction principale () peut sortir sans que le (deuxième) thread n'ait a donné son résultat.

Le spécificateur externe

En termes simples, pour une déclaration, la mémoire n'est pas allouée pour la variable ou la fonction, tandis qu'une définition, la mémoire est allouée. Le mot réservé externe permet de déclarer une variable ou une fonction globale dans un fichier mais défini dans un autre. Ces fichiers sont appelés unités de traduction pour l'application C ++ complète.

Tapez le programme suivant et enregistrez-le avec le nom de fichier, Mainfile:

#inclure
Utilisation de Namespace Std;
int myint;
Const Char Ch;
void myfn ();
int main()

myfn ();
retour 0;

La variable, MyInt, la variable constante, CH et la fonction, myfn (), ont été déclarées sans être définie.

Tapez le programme suivant avec les définitions et enregistrez-le avec le nom de fichier, autre fichier, dans le même répertoire:

#inclure
Utilisation de Namespace Std;
int myInt = 10;
const char ch = 'c';
void myfn ()

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

Essayez de compiler l'application au terminal (invite de commande DOS) avec la commande suivante, et notez qu'elle peut ne pas compiler:

g ++.CPP autre fichier.cpp -o complet.exe

Maintenant, précédez les trois déclarations en file principale avec le mot «externe», comme suit:

extern int myint;
Extern const char ch;
extern void myfn ();

Re-Save Mainfile. Compilez l'application avec:

g ++.CPP autre fichier.cpp -o complet.exe

(C'est ainsi que des fichiers séparés pour la même application sont compilés en C ++)

Et il devrait compiler. Maintenant, exécutez l'application, complète.exe, et la sortie doit être:

myfn () dit 10 et c

Notez qu'avec l'utilisation de «Extern», une variable constante peut être déclarée dans un fichier mais défini dans un autre. Lorsque vous traitez la déclaration et la définition des fonctions dans différents fichiers, l'utilisation de l'extern est facultative.

Quand utiliser extern? Utilisez-le lorsque vous n'avez pas de fichiers d'en-tête avec des déclarations globales.

«Extern» est également utilisé avec les déclarations de modèle - voir plus tard.

Conclusion:

Une variable précédée avec const et / ou volatile est un type qualifié CV. Une variable, non précédée avec const ou volatile ou les deux, est un type non cvalifié CV.

Les spécificateurs de classe de stockage sont statiques, mutables, thread_local et exter. Ceux-ci affectent la durée de vie (durée), le lieu et le mode d'emploi des variables dans une application.