Les constantes dans C++

de | 26 octobre 2018


Les constantes sont des expressions à valeur fixe.

Les littéraux

Les littéraux sont le type le plus évident de constantes. Ils sont utilisés pour exprimer des valeurs particulières dans le code source d’un programme. Nous en avons déjà utilisé dans les chapitres précédents pour donner des valeurs spécifiques à des variables ou pour exprimer des messages que nos programmes devaient imprimer, par exemple, lorsque nous avons écrit:

a = 5;

Le 5 dans ce morceau de code était une constante littérale.

Les constantes littérales peuvent être classées en: entier, virgule flottante, caractères, chaînes de caractères, booléen, pointeurs et littéraux définis par l’utilisateur.

Nombres entiers

1776
707
-273

Ce sont des constantes numériques qui identifient des valeurs entières. Notez qu’ils ne sont pas mis entre guillemets ou tout autre caractère spécial; ils sont une simple succession de chiffres représentant un nombre entier en base décimale; par exemple, 1876 représente toujours la valeur mille huit cent soixante-seize.

En plus des nombres décimaux (ceux que la plupart d’entre nous utilisons quotidiennement), C ++ permet d’utiliser des nombres octaux (base 8) et des nombres hexadécimaux (base 16) comme constantes littérales. Pour les littéraux octaux, les chiffres sont précédés d’un caractère 0 (zéro). Et pour l’hexadécimal, ils sont précédés des caractères 0x (zéro, x). Par exemple, les constantes littérales suivantes sont toutes équivalentes:

75 // décimal
0113 // octal
0x4b // hexadécimal

Tous représentent le même nombre: 75 (soixante-quinze), exprimés respectivement en chiffres de base 10, en chiffres octaux et en chiffres hexadécimaux.

Ces constantes littérales ont un type, tout comme les variables. Par défaut, les littéraux entiers sont de type int. Toutefois, certains suffixes peuvent être ajoutés à un littéral entier pour spécifier un type entier différent:

Suffixe     Type
u ou U    unsigned
l ou L      long
ll ou LL  long long

Unsigned peut être combiné avec n’importe lequel des deux autres dans n’importe quel ordre pour former unsigned long ou unsigned long long.

Par exemple:

75 // int
75u // unsigned int
75l // long
75ul // non signé long
75lu // non signé long

Dans tous les cas ci-dessus, le suffixe peut être spécifié en lettres majuscules ou minuscules.

Chiffres à virgule flottante

Ils expriment des valeurs réelles, avec des nombres décimaux et / ou des exposants. Ils peuvent inclure soit un point décimal, un caractère e, ou à la fois un point décimal et un caractère e:

3.14159 // 3.14159
6.02e23 // 6.02 x 10 ^ 23
1.6e-19 // 1,6 x 10 ^ -19
3.0 // 3.0

Ce sont quatre nombres valides avec des décimales exprimées en C ++. Le premier nombre est PI, le second est le nombre d’Avogadro, le troisième est la charge électrique d’un électron (un nombre extrêmement petit) – tous approximativement – et le dernier est le nombre trois exprimé par un nombre flottant. Point littéral numérique.

Le type par défaut pour les littéraux à virgule flottante est double. Les littéraux en virgule flottante de type float ou long double peuvent être spécifiés en ajoutant l’un des suffixes suivants:

Suffixe     Type
f ou F        float
l ou L        long double

Par exemple:

3.14159L // long double
6.02e23f // float

Toutes les lettres pouvant faire partie d’une constante numérique à virgule flottante (e, f, l) peuvent être écrites en utilisant des lettres minuscules ou majuscules sans différence de sens.

Les chaînes de caractères

Les chaînes de caractères sont entre guillemets:

‘z’
‘p’
« Bonjour tout le monde »
« Comment allez-vous? »

Les deux premières expressions représentent des littéraux à un caractère et les deux suivantes représentent des littéraux de chaîne composés de plusieurs caractères. Notez que pour représenter un seul caractère, nous le plaçons entre guillemets simples (‘), et pour exprimer une chaîne de caractères (généralement composée de plusieurs caractères), nous plaçons les caractères entre guillemets doubles (« ).

À lire aussi  La mémoire dynamique dans C++

Les littéraux à un seul caractère et les chaînes de caractères nécessitent des guillemets pour les distinguer des identificateurs de variable possibles ou des mots clés réservés. Remarquez la différence entre ces deux expressions:

x
‘x’

Ici, x seul ferait référence à un identifiant, tel que le nom d’une variable ou un type composé, alors que ‘x’ (entre guillemets simples) ferait référence au caractère littéral ‘x’ (le caractère qui représente un minuscule x lettre).

Les littéraux de caractères et de chaînes peuvent également représenter des caractères spéciaux difficiles ou impossibles à exprimer autrement dans le code source d’un programme, comme nouvelle ligne (\ n) ou tabulation (\ t). Ces caractères spéciaux sont tous précédés d’un caractère barre oblique inverse (\).

Ici vous avez une liste des codes d’échappement à caractère unique:

Code d’échappement Description
\ n                                        nouvelle ligne
\ r                                         retour chariot
\ t                                          onglet
\ v                                         onglet vertical
\ b                                         retour arrière
\ f                                          form feed (page feed)
\                                            une alerte (bip)
\’                                            simple citation (‘)
\ »                                           double citation (« )
\?                                          point d’interrogation (?)
\\                                          antislash (\)

Par exemple:

‘\ n’
‘\ t’
« Gauche \ t Droite »
« un \ ndeux trois »

En interne, les ordinateurs représentent les caractères sous forme de codes numériques: le plus souvent, ils utilisent une extension du système de codage de caractères ASCII (voir Code ASCII pour plus d’informations). Les caractères peuvent également être représentés en littéraux à l’aide de son code numérique en écrivant un caractère barre oblique inverse (\) suivi du code exprimé en tant que nombre octal (base-8) ou hexadécimal (base-16). Pour une valeur octale, la barre oblique inversée est suivie directement par les chiffres; tandis que pour hexadécimal, un caractère x est inséré entre la barre oblique inverse et les chiffres hexadécimaux eux-mêmes (par exemple: \ x20 ou \ x4A).

Plusieurs littéraux de chaîne peuvent être concaténés pour former un seul littéral de chaîne en les séparant simplement par un ou plusieurs espaces vides, y compris des tabulations, des nouvelles lignes et d’autres caractères vides valides. Par exemple:

« cela forme » « une seule » « chaîne »
« de caractères « 

Ce qui précède est un littéral de chaîne équivalent à:

« cela forme une seule chaîne de caractères »

Notez que les espaces entre les guillemets font partie du littéral, alors que ceux en dehors ne le font pas.

Certains programmeurs utilisent également une astuce pour inclure de longs littéraux de chaîne dans plusieurs lignes: en C ++, une barre oblique inverse (\) à la fin de la ligne est considérée comme un caractère de continuation de ligne qui fusionne cette ligne et la suivante en une seule ligne. Donc le code suivant:

x = "chaîne exprimée dans \
deux lignes"

est équivalent à:

x = "chaîne exprimée en deux lignes"

Tous les littéraux de caractère et de chaîne décrits ci-dessus sont constitués de caractères de type char. Un type de caractère différent peut être spécifié en utilisant l’un des préfixes suivants:

À lire aussi  Instructions et flux de contrôle

Préfixe Type de caractère
u              char16_t
U             char32_t
L              wchar_t

Notez que, contrairement aux suffixes de type pour les littéraux entiers, ces préfixes sont sensibles à la casse: minuscule pour char16_t et majuscule pour char32_t et wchar_t.

Pour les littéraux de chaîne, outre les valeurs u, U et L ci-dessus, il existe deux préfixes supplémentaires:

Préfixe       Description
u8                 Le littéral de chaîne est codé dans l’exécutable à l’aide de UTF-8.
R                   Le littéral chaîne est une chaîne brute

Dans les chaînes brutes, les barres obliques inverses et les guillemets simples et doubles sont tous des caractères valides; le contenu du littéral est délimité par une R initiale « séquence (et une finale) séquence », où séquence est toute séquence de caractères (y compris une séquence vide). Le contenu de la chaîne est ce qui se trouve à l’intérieur de la parenthèse, ignorant la séquence de délimitation elle-même. Par exemple:

R "(chaîne avec \ barre oblique inverse)"
R "&% $ (chaîne avec \ antislash) &% $"

Les deux chaînes ci-dessus sont équivalentes à « chaîne avec \\ barre oblique inversée ». Le préfixe R peut être combiné à d’autres préfixes, tels que u, L ou u8.

Autres

Trois littéraux de mots clés existent en C ++: true, false et nullptr:
true et false sont les deux valeurs possibles pour les variables de type bool.
nullptr est la valeur du pointeur null.

bool foo = true;
bool bar = false;
int * p = nullptr;

Expressions typées

Parfois, il est juste pratique de donner un nom à une valeur constante:

constante double pi = 3,1415926;
const char tab = ‘\ t’;

Nous pouvons ensuite utiliser ces noms au lieu des littéraux pour lesquels ils ont été définis:

#include <iostream>
using namespace std;

const double pi = 3.14159;
const char newline = '\n';

int main ()
{
double r=5.0; // radius
double circle;

circle = 2 * pi * r;
cout << circle;
cout << newline;
}



Catégorie : C++ Étiquettes :

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *