Constantes de chaîne. Constantes et variables en langage C
Jusqu’à présent, toutes les variables que nous avons considérées ont été pas des constantes. Leurs valeurs pourraient être modifiées à tout moment. Par exemple:
entier x(4); // initialisation de la variable x avec la valeur 4 x = 5 ; // change la valeur de x en 5
Cependant, il est parfois utile d'utiliser des variables dont les valeurs ne peuvent pas être modifiées - constantes. Par exemple, la gravité sur Terre : 9,8 m/s^2. Il est peu probable que cela change dans un avenir proche. Utiliser une constante dans ce cas est la meilleure option, car de cette manière nous empêcherons tout changement (même accidentel) de la valeur.
Pour faire d'une variable une constante, utilisez le mot-clé const avant ou après le type de variable. Par exemple:
const double gravité ( 9,8 ); // il est préférable d'utiliser const avant le type de données int const SidesInSquare ( 4 ); // ok, mais pas préférable
Bien que C++ accepte const avant ou après le type, nous vous recommandons d'utiliser avant taper.
Les constantes doivent être initialisées dès l'annonce. Leurs valeurs ne peuvent pas être modifiées à l'aide de l'opération d'affectation.
const double gravité ( 9,8 ); gravité = 9,9 ; // non autorisé - erreur de compilation
Déclarer une constante sans initialisation provoquera également une erreur de compilation :
const double gravité; // erreur de compilation, la constante doit être initialisée
Veuillez noter que les constantes peuvent également être initialisées en utilisant des valeurs non const :
std :: cout<< "Enter your age: "; int age; std::cin >> âge ; const int utilisateursAge(âge); // la variable usersAge ne pourra plus être modifiée à l'avenir
const est le plus utile (et le plus couramment utilisé) avec les paramètres de fonction :
void printInteger(const int maValeur) ( std::cout<< myValue; }
void printInteger (const int maValeur) std :: cout<< myValue ; |
Ainsi, lors de l'appel d'une fonction, le paramètre constante nous indique que la fonction ne changera pas la valeur de la variable maValeur. Deuxièmement, cela garantit que la fonction ne modifie pas la valeur de myValue.
Temps de compilation et temps d'exécution
Lorsque vous êtes en train de compiler un programme, c'est temps de compilation(temps de compilation) . Le compilateur vérifie votre programme pour les erreurs de syntaxe, puis convertit le code en fichiers objets.
Lorsque vous êtes en train de démarrer votre programme ou lorsque le programme est déjà en cours d'exécution, c'est durée d'exécution(délai de mise en œuvre). Le code est exécuté ligne par ligne.
Constexpr
Il existe deux types de constantes en C++.
Constantes rinheure. Leurs valeurs sont déterminées uniquement au moment de l'exécution (lorsque le programme est en cours d'exécution). Les variables comme usersAge et myValue (dans le code ci-dessus) sont des constantes d'exécution car le compilateur ne peut pas déterminer leurs valeurs au moment de la compilation. usersAge dépend de l'entrée de l'utilisateur (qui ne peut être reçue que pendant l'exécution du programme), et myValue dépend de la valeur transmise à la fonction (qui sera également connue lors de l'exécution du programme).
Constantes ctemps de compilation. Leurs valeurs sont déterminées au moment de la compilation. Par exemple, la gravité de la Terre est une constante au moment de la compilation ; nous l'avons déterminée nous-mêmes lors de l'écriture du programme.
Dans la plupart des cas, le type de constante n'a pas d'importance : au moment de la compilation ou au moment de l'exécution. Cependant, il existe encore quelques situations dans lesquelles C++ peut nécessiter une constante de compilation au lieu d'une constante d'exécution (par exemple, lors de la détermination de la longueur d'un tableau de taille fixe - nous y reviendrons plus tard). Puisqu'il existe deux types, le compilateur doit surveiller en permanence quelle variable appartient à laquelle d'entre elles. Pour faciliter cette tâche, C++11 introduit le mot-clé constexpr, qui garantit que le type de la constante est au moment de la compilation :
constexpr double gravité (9,8) ; // ok, la valeur est déterminée au moment de la compilation constexpr int sum = 4 + 5; // ok, la valeur 4 + 5 est déterminée au moment de la compilation std::cout<< "Enter your age: "; int age; std::cin >> âge ; constexpr int monAge = âge; // pas ok, la variable age n'est pas définie à la compilation
Vous ne l'utiliserez probablement pas, mais cela ne fera pas de mal de le savoir.
Règle : Toute variable qui ne doit pas changer de valeur après l'initialisation doit être déclarée comme const (ou comme constexpr).
Noms constants
Certains programmeurs écrivent les noms de constantes en majuscules. D'autres utilisent des noms normaux, uniquement avec un préfixe « k ». Nous ne les soulignerons en aucun cas, puisque les constantes sont les mêmes variables ordinaires, juste avec des valeurs fixes, c'est tout. Il n’y a aucune raison particulière de les souligner. Cependant, c'est l'affaire de chaque individu.
Constantes de caractères
DANS leçon précédente, nous avons discuté des « nombres magiques » - des littéraux utilisés dans un programme comme constantes. Puisque leur utilisation est une mauvaise pratique, que devriez-vous utiliser à la place ? Réponse : des constantes symboliques. Symbolique(ou bien symbolique) constante– c'est le même littéral (nombre magique), uniquement avec un identifiant. Il existe deux manières de déclarer des constantes symboliques en C++. L’un d’eux est bon et l’autre moins bon. Regardons les deux.
Mauvaise pratique : utilisation d'objets macro avec du texte de remplacement comme constantes de caractères
Cette méthode était autrefois largement utilisée, vous pouvez donc toujours la voir dans les anciens codes.
DANS Leçon 22 sur les préprocesseurs et les directives, nous avons dit que les objets macro ont deux formes - avec et sans texte de remplacement. Regardons le premier cas (avec texte de remplacement). Cela ressemble à ceci :
#define identifiant substitution_text
Une fois que le préprocesseur rencontre cette directive, toutes les occurrences ultérieures de « identifier » seront remplacées par « substitution_text ». L'identifiant est généralement écrit en majuscules avec des traits de soulignement au lieu d'espaces.
Par exemple:
int max_students = numClassrooms * MAX_STUDENTS_PER_CLASS ;
#définir MAX_STUDENTS_PER_CLASS 30 |
Au moment de la compilation, le préprocesseur remplacera tous les identifiants MAX_STUDENTS_PER_CLASS par le littéral 30.
D'accord, c'est une bien meilleure option que d'utiliser des nombres magiques, pour au moins plusieurs raisons. MAX_STUDENTS_PER_CLASS fournit un contexte sur ce qu'est cette valeur et pourquoi elle est nécessaire, même sans commentaires. Deuxièmement, si le numéro doit être modifié, il suffira de modifier uniquement la directive #define ; tous les autres identifiants MAX_STUDENTS_PER_CLASS du programme seront automatiquement remplacés par la nouvelle valeur lors de la recompilation.
Regardons un autre exemple :
#define MAX_STUDENTS_PER_CLASS 30 #define MAX_NAME_LENGTH 30 int max_students = numClassrooms * MAX_STUDENTS_PER_CLASS; setMax(MAX_NAME_LENGTH);
#définir MAX_STUDENTS_PER_CLASS 30 #define MAX_NAME_LENGTH 30 int max_students = numClassrooms * MAX_STUDENTS_PER_CLASS ; setMax(MAX_NAME_LENGTH); |
Il est clair ici que MAX_STUDENTS_PER_CLASS et MAX_NAME_LENGTH sont censés être des objets différents, même s'ils ont les mêmes valeurs (30).
Alors pourquoi cette méthode est-elle mauvaise ? Il y a deux raisons.
Premièrement, les macros sont traitées par un préprocesseur, qui remplace les identifiants par des valeurs spécifiques. Ces valeurs n'apparaîtront pas dans le débogueur (qui affiche votre code réel). Une fois compilé, int max_students = numClassrooms * 30; dans le débogueur, vous verrez int max_students = numClassrooms * MAX_STUDENTS_PER_CLASS; . Que faire si vous avez besoin de connaître la valeur de MAX_STUDENTS_PER_CLASS ? Vous devrez le trouver vous-même dans le code. Et cela peut prendre un certain temps, selon la taille du programme.
Deuxièmement, ces directives ont toujours une portée globale (nous en reparlerons plus tard). Cela signifie que les valeurs #define dans une partie du code peuvent entrer en conflit avec les valeurs #define dans une autre partie du code.
Règle : n'utilisez pas #define pour créer des constantes de caractères.
Bonne méthode : variables const
La meilleure façon de créer une constante de caractère est d'utiliser const :
const int maxStudentsPerClass ( 30 ); const int maxNameLength ( 30 );
const int maxStudentsPerClass ( 30 ) ; const int maxNameLength ( 30 ) ; |
Ces valeurs seront affichées dans le débogueur et suivront également toutes les règles des variables régulières (y compris la portée).
Règle : Utiliserconstpour créer des constantes symboliques.
Utiliser des constantes de caractères dans un programme
Dans de nombreux programmes, une constante de caractère doit être utilisée dans tout le code (pas seulement à un seul endroit). Il peut s'agir de constantes physiques ou mathématiques qui ne changent pas (par exemple, le nombre Pi ou Avogadro) ou de valeurs spécifiques de votre programme. Afin de ne pas les écrire à chaque fois que vous en avez besoin, définissez-les au même endroit et utilisez-les partout où vous en avez besoin. De cette façon, si vous devez les modifier, il suffira d'aller dans un seul fichier et d'y apporter des modifications, plutôt que de parcourir tout le programme.
Comment faire cela ? Très simple :
- Créez un fichier d'en-tête pour stocker les constantes.
- Dans le fichier d'en-tête, déclarez l'espace de noms (
De vraies constantes
Constantes entières
Constantes dans les programmes
Les constantes sont des objets qui ne peuvent pas être utilisés sur le côté gauche de l'opérateur d'affectation, car une constante est une valeur non adressable et, bien qu'elle soit stockée dans la mémoire de l'ordinateur, il n'existe généralement aucun moyen de connaître son adresse. En langage C, les constantes sont :
Données arithmétiques, caractères et chaînes auto-définies ;
Identificateurs de tableaux et de fonctions ;
Éléments d'énumération.
Les constantes arithmétiques peuvent être de type entier ou réel.
Format général : ± n(+ n'est généralement pas inclus).
Constantes décimales- une séquence de nombres 0...9, dont le premier ne doit pas être 0. Par exemple, 22 et 273 sont des constantes entières ordinaires si vous devez saisir une constante entière longue, alors l'attribut est indiqué ; L(je) - 273L (273je). Pour une telle constante, 4 octets seront alloués. Une constante entière régulière trop longue pour le type int, est traité comme un type plus long ( long ou très longtemps).
Il existe un système de notation pour les constantes octales et hexadécimales.
Constantes octales- une suite de nombres de 0 à 7 dont le premier doit être 0, par exemple : 020 = 16 décimal.
Constantes hexadécimales- une suite de chiffres de 0 à 9 et de lettres de A à F (a...f), commençant par les symboles 0Х (0х), par exemple : 0X1F (0х1f) = 31 décimal.
Les constantes octales et hexadécimales peuvent également se terminer par la lettre L(l) - longue, par exemple 020L ou 0X20L.
Exemples de constantes entières :
1992 13 1000L - décimal ;
0777 00033 01l - octal ;
0x123 0X00ff 0xb8000l - hexadécimal.
Ces constantes sont stockées en mémoire sous double format, et en représentation externe elles peuvent avoir deux formes :
1) avec point décimal fixe, format d'enregistrement : ± n.m, Où n, m- les parties entières et fractionnaires d'un nombre ;
2) virgule décimale flottante (forme exponentielle) : ± n.m E ± p, Où n, m- parties entières et fractionnaires d'un nombre, r- l'ordre, par exemple, 1,25×10 -8 s'écrit 1,25E-8.
Exemples de constantes à virgule fixe et flottante :
1.0 -3.125100е-10 0.12537е+13
Une constante de caractère est un caractère entouré de guillemets simples : "A", "x" (occupe 1 octet).
Le langage C utilise et. spécial (gestion ) caractères non affichés à l'écran; leur but est d'influencer l'ordre dans lequel les autres caractères sont affichés. Puisqu'ils ne sont pas affichés à l'écran, une paire de caractères est utilisée pour les indiquer dans le texte du programme, dont le premier est toujours une barre oblique inverse ( barre oblique inverse) ("\"). Les principaux sont :
La barre oblique inverse dans les constantes de caractère et de chaîne (voir ci-dessous) représente également certains caractères ordinaires dont l'écriture entraînerait une ambiguïté :
Lors de l'affectation à une variable de caractère, ces séquences doivent être entourées d'apostrophes. Constante de caractère "\0" (à ne pas confondre avec le symbole - nombre"0" !) est souvent écrit à la place de la constante entière 0 pour souligner la nature symbolique de certaines expressions (voir la rubrique "Chaînes").
Exemples de constantes de caractères : "A", "9", "$", "\n", "\"".
En C, les caractères sont entourés d'apostrophes. Ainsi, lorsque nous attribuons une valeur à une variable grillé taper carboniser, il faut écrire
grillé = "T"; /* DROITE */,
grillé = T; /* FAUX */
Si les apostrophes sont omises, le compilateur « pense » que nous utilisons une variable appelée T, qu'ils ont oublié de décrire.
Le standard du langage C a adopté la règle selon laquelle les valeurs d'une variable ou constante de type carboniser il ne peut y avoir que des caractères uniques. Par conséquent, la séquence d'instructions ci-dessous n'est pas valide car elle tente d'attribuer à une variable bovine une valeur composée de deux caractères :
éhar bovin;
bovin = « bœuf » ; /*FAUX */
Si vous regardez la table des codes ASCII, vous verrez que certains des "caractères" qu'elle contient ne sont pas imprimés. Par exemple, lorsque vous utilisez le caractère numéro 7 dans un programme, le terminal informatique émet un bip. Mais comment utiliser un caractère qu’on ne peut pas saisir au clavier ? Il existe deux manières de procéder en langage C.
DANS première méthode le code ASCII lui-même est utilisé. Il vous suffit de spécifier le numéro de caractère ainsi que la barre oblique inverse précédente. Nous l’avons déjà fait dans notre programme d’équivalent or. C'est la ligne
bip = "07" ;
Il y a ici deux points importants que vous devez clairement comprendre. La première est que la séquence de caractères est entourée d’apostrophes de la même manière qu’un caractère normal. La seconde est que le numéro de caractère doit être écrit en octal. Lors de l'écriture d'une séquence de caractères, nous pouvons accidentellement omettre des zéros dans les premières positions ; dans ce cas, pour représenter le code "signal" on pourrait utiliser "7" ou même "7" . Mais vous ne devez en aucun cas omettre les derniers zéros de vos saisies ! Séquence de caractères "20" peut s'écrire sous la forme "20" , mais pas "2" .
Lorsque vous utilisez du code ASCII, il est important de noter la différence entre les nombres et les symboles numériques. Par exemple, le symbole "4" correspond à un code ASCII de 52. C'est le caractère "4" pas le numéro 4.
RIZ. 3. 4. Formes d'écriture de constantes de types entiers
Dans la deuxième façon Pour représenter les caractères « gênants », des séquences spéciales de symboles sont utilisées. Celles-ci sont appelées séquences d'échappement et ressemblent à ceci :
n nouvelle ligne
onglet t
b prendre du recul
r retour chariot
f soumettre le formulaire
barre oblique inverse()
"apostrophe(")
"citations (")
Lors de l'affectation à une variable de caractère, ces séquences doivent également être entourées d'apostrophes. Par exemple, nous pourrions écrire la déclaration
nerf = "n" ;
puis imprimez la variable nerf; cela avancera d’une ligne sur le périphérique d’impression ou l’écran d’affichage.
Les cinq premières séquences de contrôle sont des caractères communs destinés à contrôler le fonctionnement du dispositif d'impression :
le caractère « nouvelle ligne » provoque une nouvelle ligne ;
le caractère "tabulation" déplace le curseur ou la tête d'impression d'un certain nombre fixe de positions 5 ou 8 ;
le symbole « reculer » recule d'une position ;
Le caractère retour chariot revient au début de la ligne ;
Le symbole « saut de page » entraîne l'alimentation du papier d'une page.
Dans les trois dernières séquences d'échappement, les personnages , " , " peuvent être considérées comme des constantes symboliques [puisqu'elles servent à définitions constantes de caractères et sont directement utilisées dans l'instruction printf(), les utiliser eux-mêmes comme symboles conduirait à une erreur]. Si vous souhaitez imprimer une chaîne.
N'oubliez pas que "le caractère s'appelle une barre oblique inverse".
l'opérateur ressemblera à ceci :
printf(" Rappelez-vous, " le caractère s'appelle une barre oblique inverse. " n");
Ici, vous pouvez avoir deux questions. Premièrement, pourquoi n’avons-nous pas mis les séquences d’échappement entre apostrophes ? Deuxièmement, quand devez-vous utiliser le code ASCII et quand utilisez-vous les séquences d’échappement dont nous venons de parler ? (Nous espérons que ce sont les questions que vous vous posez, CAR ce sont les questions auxquelles nous allons répondre.)
Constantes entières
Constantes à virgule flottante
Constantes de caractères
Cordes
Zéro
Const
Transferts
C++ vous permet d'écrire des valeurs des principaux types : constantes de caractères, constantes entières et constantes à virgule flottante. De plus, zéro (0) peut être utilisé comme constante de n’importe quel type de pointeur et les chaînes de caractères sont des constantes de type char. Vous pouvez également spécifier des constantes symboliques. Une constante symbolique est un nom dont la valeur ne peut pas être modifiée dans sa portée. Il existe trois types de constantes symboliques en C++ :
Toute valeur de n'importe quel type peut recevoir un nom et être utilisée comme constante en ajoutant le mot-clé const à sa description ;
un ensemble de constantes entières peut être défini comme une énumération ;
tout nom de vecteur ou de fonction est une constante.
Constantes entières
Les constantes entières se présentent sous quatre formes : constantes décimales, octales, hexadécimales et caractères. Les décimales sont utilisées le plus souvent et ressemblent à ce à quoi vous vous attendez :
leurs équivalents décimaux sont 0, 2, 63, 83. En notation hexadécimale, ces constantes ressemblent à ceci :
| 0x0 | 0x2 | 0x3f | 0x53 |
Les lettres a, b, c, d, e et f, ou leurs équivalents majuscules, sont utilisées pour représenter respectivement les nombres 10, 11, 12, 13, 14 et 15. Les notations octales et hexadécimales sont particulièrement utiles pour enregistrer un ensemble de bits ; utiliser ces notations pour exprimer des nombres ordinaires peut réserver des surprises. Par exemple, sur une machine où int est représenté comme un complément hexadécimal binaire, 0xffff est le nombre décimal négatif -1 ; si plus de bits étaient utilisés pour représenter le tout, ce serait 65535.
Constantes à virgule flottante
Les constantes à virgule flottante sont de type double. Comme dans le cas précédent, le compilateur doit avertir des constantes à virgule flottante trop grandes pour être représentées. Voici quelques constantes à virgule flottante :
1,23 0,23 0,23 1. 1,0 1,2e10 1,23e-15
Notez qu'il ne peut pas y avoir d'espace au milieu d'une constante à virgule flottante. Par exemple, 65.43 e-21 n'est pas une constante à virgule flottante, mais quatre symboles lexicaux distincts (jetons) :
65.43e-21
et provoquera une erreur de syntaxe.
Si vous souhaitez avoir une constante à virgule flottante de type float, vous pouvez la définir comme ceci :
Const flottant pi = 3,14159265 ;
Constantes de caractères
Bien qu'en C++ il n'y ait pas de type de données caractère distinct, plus précisément, un caractère peut être stocké dans un type entier, il possède une entrée spéciale et pratique pour les caractères ; Une constante de caractère est un caractère entouré de guillemets simples ; par exemple, « a » ou « 0 ». De telles constantes de caractères sont en réalité des constantes symboliques pour une valeur entière de caractères dans le jeu de caractères de la machine sur laquelle le programme sera exécuté (qui n'est pas nécessairement le même que le jeu de caractères utilisé sur la machine sur laquelle le programme est compilé). Par conséquent, si vous utilisez une machine utilisant le jeu de caractères ASCII, la valeur de "0" sera 48, mais si votre machine utilise EBCDIC, elle sera 240. L'utilisation de constantes de caractères au lieu de la notation décimale rend le programme plus portable. Plusieurs caractères ont également des noms standard qui utilisent une barre oblique inverse \\ comme caractère d'échappement :
Contrairement à leur apparence, chacun est un symbole. Vous pouvez également représenter un caractère sous la forme d'un nombre octal à un, deux ou trois chiffres (le caractère \\ suivi de chiffres octaux), ou sous la forme d'un nombre hexadécimal à un, deux ou trois chiffres (\\x suivi de chiffres hexadécimaux). Par exemple:
"\\6" "\\x6" 6 Accusé de réception ASCII
"\\60" "\\x30" 48 ASCII "0"
"\\137" "\\x05f" 95 ASCII "_"
Cela permet de représenter chaque caractère du jeu de caractères de la machine, et notamment d'insérer ces caractères dans des chaînes de caractères. L'utilisation de la notation numérique pour les caractères rend le programme non portable entre des machines dotées de jeux de caractères différents.
Cordes
Une constante chaîne est une séquence de caractères entourée de guillemets :
"c'est une chaîne"
Chaque constante de chaîne contient un caractère de plus qu'il n'y paraît ; ils se terminent tous par le caractère vide "\\0" avec la valeur 0.
Par exemple:
Taillede("asdf")==5;
La chaîne C est de type "un vecteur du nombre approprié de caractères", donc "asdf" est de type char. Une chaîne vide s'écrit "" (et est de type char). Notez que pour chaque chaîne s strlen(s)==sizeof(s)-1, puisque strlen() ne respecte pas le 0 final.
La convention de barre oblique inverse pour représenter les caractères non graphiques peut également être utilisée dans une chaîne. Cela permet de représenter des guillemets doubles et le caractère d'échappement \\ dans une chaîne. Le caractère le plus courant de ce type est bien entendu le caractère de nouvelle ligne "\\n".
Par exemple:
Cout<< "гудок в конце сообщения\\007\\n"
Où 7 est la valeur ASKII du caractère bel (cloche).
Il est impossible d'avoir une "vraie" nouvelle ligne dans une chaîne :
"ce n'est pas une chaîne
il y a une erreur de syntaxe"
Cependant, une ligne peut contenir une barre oblique inverse suivie immédiatement d'une nouvelle ligne ; les deux seront ignorés.
Par exemple:
Cout<< "здесь все \\
d'accord"
imprimera
Tout va bien ici
Une nouvelle ligne précédée d'un échappement n'entraîne pas une nouvelle ligne dans la ligne ; c'est simplement une convention d'écriture.
Il est possible d'avoir un caractère nul dans une chaîne, mais la plupart des programmes ne supposeront pas qu'il y a des caractères après celui-ci. Par exemple, la chaîne "asdf\\000hjkl" sera traitée comme "asdf" par les fonctions standards comme strcpy() et strlen().
Lors de l'insertion d'une constante numérique dans une chaîne en notation octale ou hexadécimale, il est prudent de toujours utiliser un nombre à trois chiffres. Il est déjà assez difficile de lire un enregistrement sans avoir à se demander si le caractère après la constante est un chiffre ou non. Considérez ces exemples :
Char v1 = "a\\x0fah\\0129" ; // "a" "\\xfa" "h" "\\12" "9"
char v2 = "a\\xfah\\129"; // "a" "\\xfa" "h" "\\12" "9"
char v3 = "a\\xfad\\127"; // "a" "\\xfad" "\\127"
Et gardez à l’esprit que la notation hexadécimale à deux chiffres ne suffira pas sur les machines dotées d’un octet de 9 bits.
Zéro
H ol (0) peut être utilisé comme constante de n’importe quel type entier, flottant ou pointeur. Aucun objet n'est localisé à l'adresse 0. Le type de zéro est déterminé par le contexte. Il est généralement (mais pas nécessairement) représenté par un ensemble de bits entièrement nuls de longueur appropriée.
Const
Le mot-clé const peut être ajouté à la déclaration d'un objet pour faire de cet objet une constante plutôt qu'une variable.
Par exemple:
Modèle const int = 145 ;
const int v = ( 1, 2, 3, 4 );
Puisque rien ne peut être affecté à une constante, celle-ci doit être initialisée. Déclarer quelque chose comme const garantit que sa valeur ne change pas de portée :
Modèle = 145 ; // erreur
modèle++ ; // erreur
Notez que const modifie le type, c'est-à-dire qu'il restreint la façon dont l'objet peut être utilisé, plutôt que de spécifier comment la constante doit être placée. Par conséquent, par exemple, il est tout à fait raisonnable, et parfois utile, de décrire une fonction comme renvoyant const :
Const char* coup d'oeil (int i)
{
retourner privé[i] ;
}
Une fonction comme celle-ci pourrait être utilisée pour permettre à quelqu'un de lire une ligne qui ne peut pas être écrasée ou réécrite (par cette personne).
D'un autre côté, le compilateur peut profiter du fait qu'un objet est une constante de plusieurs manières (en fonction de son intelligence, bien sûr). La chose la plus évidente est qu’une constante n’a pas besoin d’allouer de mémoire car le compilateur connaît sa valeur. De plus, un initialiseur constant est souvent (mais pas toujours) une expression constante, ce qui signifie qu'il peut être évalué au moment de la compilation. Cependant, un vecteur de constantes doit généralement se voir allouer de la mémoire car le compilateur ne peut généralement pas déterminer quels éléments du vecteur sont référencés dans les expressions. Cependant, sur de nombreuses machines, même dans ce cas, des gains d'efficacité peuvent être obtenus en plaçant des vecteurs constants dans une mémoire morte.
Et l'utilisation d'un pointeur implique deux objets : le pointeur lui-même et l'objet pointé. Préfixer une déclaration de pointeur avec const fait de l'objet, mais pas du pointeur lui-même, une constante.
Par exemple:
Const char* pc = "asdf"; // pointeur vers une constante
pc = "un" ; // erreur
pc = "ghjk"; // d'accord
Pour décrire le pointeur lui-même, et non l'objet pointé, comme constante, l'opérateur const* est utilisé.
Par exemple:
Char *const cp = "asdf"; // pointeur constant
cp = "un" ; // d'accord
cp = "ghjk"; // erreur
Pour rendre les deux objets constants, ils doivent tous deux être déclarés const.
Par exemple:
Const char *const cpc = "asdf"; // const pointeur vers const
cpc = "un" ; // erreur
cpc = "ghjk" ; // erreur
Un objet qui est une constante lorsqu'il est accessible via un seul pointeur peut être une variable lorsqu'il est accessible via d'autres chemins. Ceci est particulièrement utile pour les paramètres de fonction. En déclarant un paramètre pointeur comme fonction const, il lui est interdit de modifier l'objet vers lequel il pointe.
Par exemple:
Char* strcpy(char* p, const char* q); // ne peut pas changer q
Le pointeur vers une constante peut se voir attribuer l'adresse d'une variable, car cela ne peut causer aucun dommage. Cependant, vous ne pouvez pas attribuer l'adresse d'une constante à un pointeur qui n'a pas été contraint, car cela permettrait à la valeur de l'objet de changer.
Par exemple:
Int a = 1 ;
const c = 2 ;
const* p1 = // ok
const* p2 = // ok
int* p3 = // erreur
*p3 = 7 ; // change la valeur de c
Comme d'habitude, si un type est omis dans la description, il est supposé être un type int.
Transferts
Il existe une autre méthode pour définir des constantes entières qui est parfois plus pratique que d'utiliser const.
Par exemple:
Énumération (ASM, AUTO, BREAK);
Définit trois constantes entières, appelées énumérateurs, et leur attribue des valeurs. Puisque les valeurs des énumérateurs sont attribuées par défaut à partir de 0 dans l'ordre croissant, cela équivaut à écrire :
Const ASM = 0 ;
const AUTO = 1 ;
const PAUSE = 2 ;
Une énumération peut être nommée.
Par exemple:
Mot-clé d'énumération (ASM, AUTO, BREAK) ;
Et le nom enum devient synonyme d'int, pas d'un nouveau type. Déclarer une variable mot-clé plutôt qu'un simple int peut donner au programmeur et au compilateur une indication que l'utilisation est intentionnelle.
Par exemple:
Mot-clé ;
interrupteur (clé) (
cas ASM :
// fait quelque chose
casser;
cas PAUSE :
// fait quelque chose
casser;
}
Entraîne l'émission d'un avertissement par le compilateur car seules deux des trois valeurs de mots-clés sont utilisées.
Vous pouvez également spécifier explicitement les valeurs de l'énumérateur.
Par exemple:
Énumération int16 (
signe=0100000, // signe
most_significant=040000, // le plus significatif
less_significant=1 // le moins significatif
};
Ces valeurs ne doivent pas nécessairement être différentes, croissantes ou positives.