Constantes C++
Les constantes sont des valeurs fixes qui ne changent pas pendant l'exécution du programme. Ces valeurs fixes sont également appelées valeurs littérales.
La constante peut être n'importe quel type de données de base, qui peut être divisé en nombres entiers, nombres à virgule flottante, caractères, chaînes et valeurs booléennes.
Les constantes sont comme des variables ordinaires, sauf que la valeur d'une constante ne peut pas être modifiée une fois définie.
Constantes entières
Les constantes entières peuvent être des constantes décimales, octales ou hexadécimales. Le préfixe spécifie la base : 0x ou 0X pour hexadécimal, 0 pour octal, et sans préfixe, la valeur par défaut est décimale.
Les constantes entières peuvent également avoir un suffixe. Le suffixe est une combinaison de U et L. U représente un entier non signé (non signé) et L représente un entier long (long). Le suffixe peut être en majuscule ou en minuscule, et U et L peuvent être dans n'importe quel ordre.
Voici des exemples de constantes entières :
212 // 合法的 215u // 合法的 0xFeeL // 合法的 078 // 非法的：8 不是八进制的数字 032UU // 非法的：不能重复后缀
Voici des exemples de différents types de constantes entières :
85 // 十进制 0213 // 八进制 0x4b // 十六进制 30 // 整数 30u // 无符号整数 30l // 长整数 30ul // 无符号长整数
Constantes à virgule flottante
Point flottant les constantes sont constituées d'une partie entière, d'un point décimal, d'une partie décimale et d'une partie exposant. Vous pouvez représenter des constantes à virgule flottante sous forme décimale ou exponentielle.
Lorsqu'il est exprimé sous forme décimale, le point décimal, l'exposant ou les deux doivent être inclus. Lorsqu'il est exprimé sous forme exponentielle, une partie entière, une partie décimale ou les deux doivent être incluses. Les exposants signés sont introduits par e ou E.
Voici des exemples de constantes à virgule flottante :
3.14159 // 合法的 314159E-5L // 合法的 510E // 非法的：不完整的指数 210f // 非法的：没有小数或指数 .e55 // 非法的：缺少整数或分数
Constantes booléennes
Il existe deux constantes booléennes, qui sont toutes deux des mots-clés standard C++ :
- La valeur
true représente vrai. La valeur
faux représente faux.
Nous ne devons pas traiter la valeur de vrai comme 1 et la valeur de faux comme 0.
Constantes de caractères
Les constantes de caractères sont placées entre guillemets simples. Si une constante commence par L (uniquement en majuscule), cela signifie qu'il s'agit d'une constante de caractères larges (comme L'x'), auquel cas elle doit être stockée dans une variable de type wchar_t. Sinon, il s'agit d'une constante de caractère étroite (par exemple 'x'), auquel cas elle peut être stockée dans une simple variable de type char.
Une constante de caractère peut être un caractère ordinaire (tel que 'x'), une séquence d'échappement (telle que 't') ou un caractère universel (tel que 'u02C0').
En C++, il existe des caractères spécifiques lorsqu'ils sont précédés d'une barre oblique inverse, ils ont une signification particulière et sont utilisés pour représenter des nouvelles lignes (n) ou des tabulations (t). Le tableau suivant répertorie certains de ces codes de séquence d'échappement :
| 转义序列 | 含义 |
|---|---|
| \ | 字符 |
| ' | ' 字符 |
| " | " 字符 |
| ? | ? 字符 |
| a | 警报铃声 |
| b | 退格键 |
| f | 换页符 |
| n | 换行符 |
| r | 回车 |
| t | 水平制表符 |
| v | 垂直制表符 |
| ooo | 一到三位的八进制数 |
| xhh . . . | 一个或多个数字的十六进制数 |
L'exemple suivant montre quelques caractères de séquence d'échappement :
#include <iostream>
using namespace std;
int main()
{
cout << "Hello\tWorld\n\n";
return 0;
}Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :
Hello World
String constant
String les littéraux ou les constantes sont placés entre guillemets "". Une chaîne contient des caractères similaires aux constantes de caractères : caractères ordinaires, séquences d'échappement et caractères universels.
Vous pouvez utiliser des espaces comme délimiteurs pour séparer une longue chaîne constante en lignes.
L'exemple ci-dessous montre quelques constantes de chaîne. Les chaînes affichées dans les trois formulaires suivants sont les mêmes.
"hello, dear" "hello, \ dear" "hello, " "d" "ear"
Définir des constantes
En C++, il existe deux manières simples de définir des constantes :
Utiliser le préprocesseur #define.
Utilisez le mot-clé const.
#define préprocesseur
Ce qui suit est la forme d'utilisation de #define préprocesseur pour définir des constantes :
#define identifier value
Veuillez consulter l'exemple suivant pour plus de détails :
#include <iostream>
using namespace std;
#define LENGTH 10
#define WIDTH 5
#define NEWLINE '\n'
int main()
{
int area;
area = LENGTH * WIDTH;
cout << area;
cout << NEWLINE;
return 0;
}Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :
50
const Keywords
Vous pouvez utiliser le préfixe const Déclarer une constante du type spécifié comme suit :
const type variable = value;
Veuillez consulter l'exemple suivant pour plus de détails :
#include <iostream>
using namespace std;
int main()
{
const int LENGTH = 10;
const int WIDTH = 5;
const char NEWLINE = '\n';
int area;
area = LENGTH * WIDTH;
cout << area;
cout << NEWLINE;
return 0;
}Lorsque le code ci-dessus est compilé et exécuté, il produira les résultats suivants :
50
Veuillez noter que c'est une bonne pratique de programmation de définir des constantes en lettres majuscules.
