C Variable

Les variables ne sont en fait que des noms donnés aux zones de stockage sur lesquelles un programme peut opérer. En C, chaque variable a un type spécifique, qui détermine la taille et la disposition du stockage de la variable. Les valeurs comprises dans cette plage peuvent être stockées en mémoire, et des opérateurs peuvent être appliqués à la variable.

Les noms de variables peuvent être constitués de lettres, de chiffres et de caractères de soulignement. Ils doivent commencer par une lettre ou un caractère de soulignement. Les lettres majuscules et minuscules sont différentes car C est sensible à la casse. D'après les types de base expliqués dans le chapitre précédent, il existe les types de variables de base suivants :

TypeDescription
charGénéralement un octet (huit bits). C'est un type entier.
intEntier, 4 octets, plage de valeurs de -2147483648 à 2147483647.
float

Valeur à virgule flottante simple précision. La simple précision a le format : 1 bit de signe, 8 bits d'exposant et 23 bits de fraction.

double

Valeur à virgule flottante double précision. La double précision a 1 bit de signe, 11 bits d'exposant et 52 bits de fraction.

voidIndique l'absence de type.

Le langage C permet également de définir divers autres types de variables, tels que les énumérations, les pointeurs, les tableaux, les structures, les unions, etc. Ceux-ci seront expliqués dans les chapitres suivants. Dans ce chapitre, nous abordons d'abord les types de variables de base.

Définitions de variables en C

La définition de variable indique au compilateur où et comment créer l'espace de stockage d'une variable. Une définition de variable spécifie un type de données et contient une liste d'une ou plusieurs variables de ce type, comme indiqué ci-dessous :

type variable_list;

typeIndique le type de données de la variable. Il peut être entier, à virgule flottante, caractère, pointeur, etc., et il peut aussi être un objet défini par l'utilisateur.

variable_listPeut être constitué d'un ou plusieurs noms de variables, plusieurs variables étant séparées par des virgules.,Séparées. Les variables sont constituées de lettres, de chiffres et de traits de soulignement, et commencent par une lettre ou un trait de soulignement.

Voici plusieurs déclarations valides :

Définir une variable entière :

int age;

Dans le code ci-dessus, age est défini comme une variable entière.

Définir une variable à virgule flottante :

float salary;

Dans le code ci-dessus, salary est défini comme une variable à virgule flottante.

Définir une variable de type caractère :

char grade;

Dans le code ci-dessus, grade est défini comme une variable de type caractère.

Définir une variable pointeur :

int *ptr;

Dans le code ci-dessus, ptr est défini comme une variable pointeur d'entier.

Définir plusieurs variables :

int    i, j, k;

int i, j, k;Déclaration et définition des variablesi, j et k, ce qui indique au compilateur de créer une variable de typeintnomméei、j、kvariable.

Initialisation des variables

Dans le langage C, l'initialisation d'une variable consiste à attribuer une valeur initiale à une variable en même temps que sa définition. L'initialisation d'une variable peut être effectuée au moment de la définition, ou dans le code ultérieur.

Un initialiseur se compose d'un signe égal suivi d'une expression constante, comme indiqué ci-dessous :

type variable_name = value;

où,typeindique le type de données de la variable,variable_nameest le nom de la variable,valeurest la valeur initiale de la variable.

Voici quelques exemples :

int x = 10;         // 整型变量 x 初始化为 10
float pi = 3.14;    // 浮点型变量 pi 初始化为 3.14
char ch = 'A';      // 字符型变量 ch 初始化为字符 'A'
int d = 3, f = 5;           // 定义并初始化 d 和 f
byte z = 22;                // 定义并初始化 z

// 声明外部变量
extern int d;
extern int f;

Pour initialiser la variable plus tard :

Dans le code après la définition de la variable, l'opérateur d'affectation peut être utilisé.=Affecter une nouvelle valeur à la variable.

type variable_name;    // 变量定义
variable_name = new_value;    // 变量初始化

Exemple comme suit :

int x;          // 整型变量x定义
x = 20;         // 变量x初始化为20
float pi;       // 浮点型变量pi定义
pi = 3.14159;   // 变量pi初始化为3.14159
char ch;        // 字符型变量ch定义
ch = 'B';       // 变量ch初始化为字符'B'

Notez que les variables doivent être initialisées avant utilisation. La valeur d'une variable non initialisée est indéfinie et peut contenir des valeurs parasites arbitraires. Par conséquent, pour éviter un comportement indéfini et des erreurs, il est recommandé d'initialiser les variables avant de les utiliser.

Variable non initialisée

En langage C, si une variable n'est pas explicitement initialisée, sa valeur par défaut dépend du type de la variable et de sa portée.

Pour les variables globales et les variables statiques (variables statiques définies à l'intérieur des fonctions et variables globales définies à l'extérieur des fonctions), leur valeur initiale par défaut est zéro.

Voici les valeurs par défaut pour différents types de variables lorsqu'elles ne sont pas explicitement initialisées :

  • Variables entières (int, short, long, etc.) : la valeur par défaut est 0.
  • Variables à virgule flottante (float, double, etc.) : la valeur par défaut est 0.0.
  • Variable de type caractère (char) : la valeur par défaut est '\0', c'est-à-dire le caractère nul.
  • Variable pointeur : la valeur par défaut est NULL, ce qui signifie que le pointeur ne pointe vers aucune adresse mémoire valide.
  • Variables de types composites tels que les tableaux, les structures et les unions : leurs éléments ou membres seront initialisés par défaut selon les règles correspondantes, ce qui peut inclure l'application récursive des règles par défaut aux éléments.

Notez que les variables locales (variables non statiques définies à l'intérieur de fonctions) ne sont pas automatiquement initialisées à des valeurs par défaut ; leurs valeurs initiales sont indéfinies (contiennent des données parasites). Par conséquent, avant d'utiliser une variable locale, vous devez lui attribuer explicitement une valeur initiale.

La valeur par défaut d'une variable en C dépend de son type et de sa portée. La valeur par défaut des variables globales et des variables statiques est0, la valeur par défaut d'une variable de type caractère est\0, la valeur par défaut des variables pointeurs est NULL, et les variables locales n'ont pas de valeur par défaut ; leurs valeurs initiales sont indéfinies.

Déclarations de variables en C

Une déclaration de variable assure au compilateur qu'une variable existe avec le type et le nom spécifiés, afin que le compilateur puisse poursuivre la compilation sans avoir besoin de connaître tous les détails de la variable. Une déclaration de variable n'a de sens qu'au moment de la compilation ; lorsque le programme est lié, le compilateur a besoin de la déclaration réelle de la variable.

Il y a deux cas de déclarations de variables :

  • 1. L'un des cas nécessite la création d'un espace de stockage. Par exemple :int aL'espace de stockage est déjà établi au moment de la déclaration.
  • 2. L'autre cas ne nécessite pas la création d'un espace de stockage, en utilisant le mot-clé extern pour déclarer un nom de variable sans le définir. Par exemple :extern int aoù les variablesapeuvent être définies dans un autre fichier.

À moins qu'il n'y aitexterncomme mot-clé ; sinon, ce sont toutes des définitions de variables.

extern int i; //声明，不是定义
int i; //声明，也是定义

Pour plus d'explications sur extern, voir :mot-clé extern en C。

Exemple

Essayez l'exemple suivant, où les variables sont déclarées en haut, mais définies et initialisées dans la fonction main :

Exemple

#include <stdio.h> // Définir les variables x et y en dehors de la fonction int x; int y; int addtwonum() { // Déclarer les variables x et y comme variables externes à l'intérieur de la fonction extern int x; extern int y; // Affectez des valeurs aux variables externes (variables globales) x et y x = 1; y = 2; return x+y; } int main() { int result; // Appeler la fonction addtwonum result = addtwonum(); printf("le résultat est : %d",result); return 0; }

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

result 为: 3

Si vous devez référencer une variable définie dans un autre fichier source, il vous suffit d'ajouter la déclaration du mot-clé extern à cette variable dans le fichier qui la référence.

Code du fichier addtwonum.c :

#include <stdio.h> /*Déclaration de variable externe*/ extern int x ; extern int y ; int addtwonum() { return x+y; }

Code du fichier test.c :

#include <stdio.h> /*Définir deux variables globales*/ int x=1; int y=2; int addtwonum(); int main(void) { int result; result = addtwonum(); printf("le résultat est : %d\n",result); return 0; }

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

$ gcc addtwonum.c test.c -o main
$ ./main
result 为: 3

Lvalues et Rvalues en C

Il existe deux types d'expressions en C :

  1. lvalue :Une expression qui pointe vers un emplacement mémoire est appelée expression lvalue. Une lvalue peut apparaître du côté gauche ou du côté droit d'un opérateur d'affectation.
  2. rvalue :Le terme rvalue désigne une valeur stockée à une certaine adresse en mémoire. Une rvalue est une expression à laquelle on ne peut pas affecter de valeur ; c'est-à-dire qu'une rvalue peut apparaître du côté droit d'un opérateur d'affectation, mais ne peut pas apparaître du côté gauche.

Les variables sont des lvalues, elles peuvent donc apparaître du côté gauche d'un opérateur d'affectation. Les littéraux numériques sont des rvalues, ils ne peuvent donc pas être affectés et ne peuvent pas apparaître du côté gauche d'un opérateur d'affectation. Ce qui suit est une instruction valide :

int g = 20;

Mais l'instruction suivante n'est pas valide et générera une erreur de compilation :

10 = 20;
autres extensions