pointeurs const et volatile
const et les mots clé volatile modifient la façon dont les pointeurs sont traités.Le mot clé de const spécifie que le pointeur ne peut pas être modifié après l'initialisation ; le pointeur est protégé contre la modification après.
Le mot clé d' volatile spécifie que la valeur associée au nom qui suit peut être modifiée par des actions autres que ceux de l'application utilisateur.Par conséquent, le mot clé d' volatile est utile pour déclarer des objets en mémoire partagée qui est accessible par plusieurs processus ou zones de données globales utilisés pour la communication avec des routines de service d'interruption.
Lorsqu'un nom est déclaré comme volatile, le compilateur recharge la valeur de la mémoire chaque fois qu'il est accessible par le programme.Cela réduit considérablement les optimisations possibles.Toutefois, lorsque l'état d'un objet peut changer de façon inattendue, il s'agit de la seule façon de garantir l'exécution du programme prévisible.
Pour déclarer l'objet désigné par le pointeur comme const ou volatile, utilisez une déclaration du formulaire :
const char *cpch;
volatile char *vpch;
Pour déclarer la valeur du pointeur - c. autrement dit., l'adresse réelle stockée dans le pointeur - comme const ou volatile, utilisez une déclaration du formulaire :
char * const pchc;
char * volatile pchv;
Le langage C++ empêché les assignations qui permettraient la modification d'un objet ou un pointeur déclaré comme const.De tels assignations enlèveraient des informations avec lesquelles vous avez déclaré l'objet ou un pointeur, violant ainsi l'intention de la déclaration d'origine.Prenons les déclarations suivantes :
const char cch = 'A';
char ch = 'B';
Compte tenu de les déclarations précédentes de deux objets (cch, de type const char, et d' ch, de type char), la déclaration suivante/initialisations sont valides :
const char *pch1 = &cch;
const char *const pch4 = &cch;
const char *pch5 = &ch;
char *pch6 = &ch;
char *const pch7 = &ch;
const char *const pch8 = &ch;
la déclaration/initialisations suivantes sont erronées.
char *pch2 = &cch; // Error
char *const pch3 = &cch; // Error
La déclaration d' pch2 déclare un pointeur dans lequel un objet constante peut être modifié et est donc supprimée.La déclaration d' pch3 spécifie qu' pointer est constante, pas l'objet ; la déclaration est pas autorisée dans la même raison que la déclaration d' pch2 est supprimée.
Les huit assignations suivantes montrent l'assignation le pointeur et en modifiant de la valeur de pointeur pour les déclarations précédentes ; pour le moment, supposons que l'initialisation est correcte pour pch1 via pch8.
*pch1 = 'A'; // Error: object declared const
pch1 = &ch; // OK: pointer not declared const
*pch2 = 'A'; // OK: normal pointer
pch2 = &ch; // OK: normal pointer
*pch3 = 'A'; // OK: object not declared const
pch3 = &ch; // Error: pointer declared const
*pch4 = 'A'; // Error: object declared const
pch4 = &ch; // Error: pointer declared const
Les pointeurs déclarés comme volatile, ou comme un mélange de const et d' volatile, obéissent aux mêmes règles.
Les pointeurs vers des objets de const sont souvent utilisés dans les déclarations de fonction comme suit :
errno_t strcpy_s( char *strDestination, size_t numberOfElements, const char *strSource );
L'instruction précédente déclare une fonction, strcpy_s, où deux des trois arguments sont de type pointeur à char.Étant donné que les arguments sont passés par référence et non par valeur, la fonction est libre de changer strDestination et strSource si strSource n'étaient pas déclarés comme const.La déclaration d' strSource comme const fournit l'appelant qu' strSource ne peut pas être modifié par la fonction appelée.
[!REMARQUE]
Étant donné qu'il existe une conversion standard typename *au typename *de const, il est permis de passer un argument de type char * à strcpy_s.Toutefois, l'inverse n'est pas vrai ; aucune conversion implicite n'existe pour supprimer l'attribut de const d'un objet ou un pointeur.
un pointeur de const d'un type donné peut être assigné à un pointeur du même type.Toutefois, un pointeur qui n'est pas const ne peut pas être assigné à un pointeur de const .Voici de code et à corriger les assignations incorrects :
// const_pointer.cpp
int *const cpObject = 0;
int *pObject;
int main() {
pObject = cpObject;
cpObject = pObject; // C3892
}
L'exemple suivant indique comment déclarer un objet comme const si vous avez un pointeur vers un pointeur vers un objet.
// const_pointer2.cpp
struct X {
X(int i) : m_i(i) { }
int m_i;
};
int main() {
// correct
const X cx(10);
const X * pcx = &cx;
const X ** ppcx = &pcx;
// also correct
X const cx2(20);
X const * pcx2 = &cx2;
X const ** ppcx2 = &pcx2;
}