C Constantes

Les constantes sont des valeurs fixes qui ne changent pas pendant l'exécution du programme. Ces valeurs fixes sont également appeléeslittéraux。

Les constantes peuvent être de n'importe quel type de données de base, comme des constantes entières, des constantes à virgule flottante, des constantes de caractère ou des littéraux de chaîne, ainsi que des constantes énumérées.

ConstantesElles sont comme des variables ordinaires, sauf que la valeur d'une constante ne peut pas être modifiée après sa définition.

Les constantes peuvent être utilisées directement dans le code, ou elles peuvent être utilisées en définissant des constantes.

Constantes entières

Les constantes entières peuvent être décimales, octales ou hexadécimales. Le préfixe spécifie la base : 0x ou 0X indique l'hexadécimal, 0 indique l'octal, et l'absence de préfixe indique le décimal par défaut.

Les constantes entières peuvent également avoir un suffixe, qui est une combinaison de U et L. U signifie entier non signé, et L signifie entier long. Le suffixe peut être en majuscules ou en minuscules, et l'ordre de U et L est arbitraire.

Voici quelques exemples de constantes entières :

212         /* 合法的 */
215u        /* 合法的 */
0xFeeL      /* 合法的 */
078         /* 非法的:8 不是八进制的数字 */
032UU       /* 非法的:不能重复后缀 */

Voici des exemples de constantes entières de différents types :

85         /* 十进制 */
0213       /* 八进制 */
0x4b       /* 十六进制 */
30         /* 整数 */
30u        /* 无符号整数 */
30l        /* 长整数 */
30ul       /* 无符号长整数 */

Les constantes entières peuvent avoir un suffixe pour indiquer le type de données, par exemple :

Exemple

int myInt = 10;
long myLong = 100000L;
unsigned int myUnsignedInt = 10U;

Constantes à virgule flottante

Les constantes à virgule flottante se composent d'une partie entière, d'un point décimal, d'une partie fractionnaire et d'un exposant. Vous pouvez utiliser la forme décimale ou la forme exponentielle pour représenter les constantes à virgule flottante.

Lorsqu'elles sont exprimées sous forme décimale, vous devez inclure la partie entière, la partie fractionnaire, ou les deux. Lorsqu'elles sont exprimées sous forme exponentielle, vous devez inclure le point décimal, l'exposant, ou les deux. L'exposant signé est introduit par e ou E.

Voici quelques exemples de constantes à virgule flottante :

3.14159       /* 合法的 */
314159E-5L    /* 合法的 */
510E          /* 非法的:不完整的指数 */
210f          /* 非法的:没有小数或指数 */
.e55          /* 非法的:缺少整数或分数 */

Les constantes à virgule flottante peuvent avoir un suffixe pour indiquer le type de données, par exemple :

Exemple

float myFloat = 3.14f;
double myDouble = 3.14159;

Constantes de caractère

Les constantes de caractère sont placées entre guillemets simples. Par exemple, 'x' peut être stocké danschardans des variables simples d'un type.

Une constante de caractère peut être un caractère ordinaire (par exemple, 'x'), une séquence d'échappement (par exemple, '\t'), ou un caractère universel (par exemple, '\u02C0').

En C, certains caractères ont une signification particulière lorsqu'ils sont précédés d'une barre oblique inverse. Ils sont utilisés pour représenter des choses comme le saut de ligne (\n) ou la tabulation (\t). Le tableau suivant répertorie certains de ces codes de séquence d'échappement :

Séquences d'échappementSignification
\\\ caractère
\'' caractère
\"" caractère
\?caractère ?
\aSonnerie d'alarme
\bRetour arrière
\fSaut de page
\nNouvelle ligne
\rRetour chariot
\tTabulation horizontale
\vTabulation verticale
\oooNombres octaux d'un à trois chiffres
\xhh . . .Nombres hexadécimaux d'un ou plusieurs chiffres

L'exemple suivant montre quelques caractères de séquence d'échappement :

Exemple

#include <stdio.h> int main() { printf("Hello\tWorld\n\n"); return 0; }

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

Hello   World

La valeur ASCII d'une constante caractère peut être convertie en une valeur entière au moyen d'un transtypage.

Exemple

char myChar = 'a';
int myAsciiValue = (int) myChar; // Convertir myChar en valeur ASCII 97

Constantes de chaîne

Les littéraux ou constantes de chaîne sont entourés de guillemets doubles" ". Une chaîne contient des caractères similaires aux constantes caractère : caractères ordinaires, séquences d'échappement et caractères universels.

Vous pouvez utiliser des espaces comme séparateurs pour diviser une constante de chaîne très longue sur plusieurs lignes.

L'exemple suivant montre quelques constantes de chaîne. Les chaînes présentées dans les trois formes suivantes sont identiques.

"hello, dear"

"hello, \

dear"

"hello, " "d" "ear"

Les constantes de chaîne en mémoire sont stockées sous forme denullTerminateur\0Fin. Par exemple :

char myString[] = "Hello, world!"; //系统对字符串常量自动加一个 '\0'

Définir des constantes

En C, il existe deux façons simples de définir des constantes :

  1. Utilisation#definePréprocesseur : #define peut définir une constante dans un programme, et elle sera remplacée par sa valeur correspondante au moment de la compilation.
  2. UtilisationconstMot-clé : le mot-clé const est utilisé pour déclarer une variable en lecture seule, c'est-à-dire que la valeur de la variable ne peut pas être modifiée pendant l'exécution du programme.

#define préprocesseur

Voici la forme permettant de définir des constantes à l'aide du préprocesseur #define :

#define 常量名 常量值

Le code suivant définit une constante nommée PI :

#define PI 3.14159
Lors de l'utilisation de cette constante dans le programme, le compilateur remplacera tous les PI par 3.14159.

Pour plus de détails, voir les exemples suivants :

Exemple

#include <stdio.h> #define LENGTH 10 #define WIDTH 5 #define NEWLINE '\n' int main() { int area; area = LENGTH * WIDTH; printf("value of area : %d", area); printf("%c", NEWLINE); return 0; }

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

value of area : 50

mot-clé const

Vous pouvez utiliserconstUne déclaration de préfixe spécifie une constante d'un type donné, comme indiqué ci-dessous :

const 数据类型 常量名 = 常量值;

Le code suivant définit une constante nommée MAX_VALUE :

const int MAX_VALUE = 100;
Lors de l'utilisation de cette constante dans le programme, sa valeur sera toujours 100 et ne peut pas être modifiée.

La déclaration const définit une constante dans une instruction :

Pour plus de détails, voir les exemples suivants :

Exemple

#include <stdio.h> int main() { const int LENGTH = 10; const int WIDTH = 5; const char NEWLINE = '\n'; int area; area = LENGTH * WIDTH; printf("valeur de area : %d", area); printf("%c", NEWLINE); return 0; }

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

value of area : 50

Notez qu'il est de bonne pratique de programmation de définir les constantes en lettres majuscules.

Différence entre #define et const

#define et const peuvent tous deux être utilisés pour définir des constantes. Lequel choisir dépend des besoins spécifiques et des habitudes de programmation. En général, il est recommandé d'utiliser le mot-clé const pour définir des constantes, car il présente les avantages de la vérification de type et de la portée, tandis que #define effectue simplement un remplacement textuel, ce qui peut entraîner des problèmes inattendus.

Il existe quelques différences entre la directive de préprocesseur #define et le mot-clé const lors de la définition de constantes :

  • Mécanisme de remplacement :#defineest un simple remplacement de texte, tandis queconstconsiste à déclarer une constante avec un type.#defineLes constantes définies avec #define sont directement remplacées par leurs valeurs correspondantes au moment de la compilation, tandis queconstLa constante définie allouera de la mémoire à l'exécution et possède des informations de type.

  • Vérification des types :#defineaucune vérification de type n'est effectuée, car il ne s'agit que d'un simple remplacement de texte. Cependant,constLa constante définie possède des informations de type, et le compilateur peut effectuer une vérification de type sur celle-ci. Cela peut aider à détecter certaines erreurs de type potentielles.

  • Portée :#defineles constantes définies avec #define n'ont aucune limitation de portée ; elles sont valides dans tout le code après leur définition. Cependant,constles constantes définies avec const ont une portée au niveau du bloc et ne sont valides que dans la portée où elles sont définies.

  • Débogage et table des symboles : en utilisant#defineLes constantes définies avec #define n'ont pas d'entrée correspondante dans la table des symboles, car elles ne sont qu'un remplacement de texte. Cependant, en utilisantconstles constantes définies avec const ont des entrées correspondantes dans la table des symboles, ce qui facilite le débogage et la lisibilité.

autres extensions