Le langage C - variables

Un programme a pour but de traiter des données. Chaque donnée a un type (nombre entier ou réel, chaîne de caractères, pointeur, image, etc...). Pour la traiter et la stocker, on utilise une variable, qui est caractérisée par un type et un nom. Par exemple, dans

float x, y;
y = 2.5;
x = 2*y;

le nombre réel 2.5 (la donnée) est stockée dans la variable de nom "y" qui a un type adapté (float). On a défini une deuxième variable x dans laquelle on met le résultat du calcul 2*y.

L'exemple montre qu'on peut déclarer plusieurs variables du même type sur une même ligne en séparant les noms des variables par une virgule. Enfin à la fin de chaque déclaration, il faut un point-virgule.

Noms

Le nom d'une variable peut être n'importe quel mot qui n'est pas une instruction du langage, il ne doit pas commencer par un chiffre et ne doit contenir que des caractères alphanumériques: a-z,A-Z,0-9 (plus éventuellement le caractère _ ('underscore', 'tiret en bas')). Les majuscules et les minuscules sont différenciées (X n'est pas la même variable que x).

Types

Voici un tableau de quelques types de base disponibles en C:

Type de donnée	déclaration en C
entier	`int`
réel simple précision	`float`
réel double précision	`double`
caractère	`char`
rien	`void`

Le type void est un type très particulier, qui ne peut pas décrire de variable (sauf dans le cas de pointeurs). Il sert essentiellement à indiquer un type de retour d'une fonction (pour une fonction qui ne renvoie rien) ou d'argument d'une fonction (pour une fonction qui ne prend pas d'argument comme main). Voici quelques exemples :

float x, y;               /* x et y sont définies comme
                          des variables réelles simple précision */
int i, j;                 /* i et j sont définies comme
                          des variables entières */
char nom_du_fichier[32];  /* nom_du_fichier est une
                          chaîne de (au plus) 32 caractères */

Précision des calculs

Lors de l'exécution du programme, les variables utilisées sont stockées dans la mémoire de l'ordinateur. La déclaration des variables permet au compilateur de savoir quelle quantité de mémoire il faut réserver pour chaque variable. Usuellement, on compte la quantité de mémoire en octets (Attention, un kilo-octet est en fait 1024 octets, le système naturel de l'informatique n'étant pas le système décimal mais le système binaire (1024 = 2^10)). Un octet représente lui 8 bits, chaque bit pouvant prendre deux valeurs (0 ou 1). Ainsi, dans 1 octet, il est possible de représenter 2^8 = 256 valeurs différentes. Prenons le cas d'une variable entière représentée sur 2 octets. Il est possible de représenter 2^16 = 65536 valeurs différentes. En gardant un bit pour le signe, cela permet de représenter les entiers uniquement dans l'intervalle [-32768, +32767]. Le passage à une représentation sur 4 octets permet d'étendre l'intervalle à [-2147483648, 2147483647], ce qui dans la majorité des cas est largement suffisant.

Le problème se complique pour la représentation des réels, car en plus d'être dans un espace infini (comme les entiers), ils sont indénombrables. Une représentation sur 4 octets ne permet de représenter que 2^32 = 4294967296 valeurs distinctes, ce qui limite la précision (par le nombre de chiffres significatifs), car la machine "arrondi" un réel à celui le plus proche parmi les 2^32 qu'elle sait représenter.

Pour augmenter la précision, il est possible de représenter les réels sur plus d'octets (il y a là un compromis à trouver entre mémoire utilisée et précision demandée). C'est le but du type double, qui permet de représenter les réels à l'aide de 8 octets au lieu de 4 pour le type float.

Une fois déclarées les variables sont utilisables pour effectuer des opérations. Typiquement, un programme affecte des valeurs aux variables, effectue des opérations sur ces variables et indique à l'utilisateur le résultat de ces opérations. Cependant, il faut bien faire attention au fait que l'on ne peut utiliser une variable que dans une partie restreinte du programme qui dépend de l'endroit où elle a été déclarée. On distingue pour cela les variables globales des variables locale.

Visibilité d'une variable

variables globales

Les variables globales sont déclarées en dehors de toute fonction, au début du fichier contenant le source (voir vide.c). Elles sont alors lisibles et modifiables dans l'ensemble du fichier après leur déclaration.

variables locales

Par contre, on appelle variable locale, une variable qui est déclarée au début d'un bloc d'instructions. On ne peut alors utiliser cette variable que dans ce bloc (et donc aussi dans tous les sous-blocs qu'il contient). En particulier, une variable déclarée dans une fonction ne peut être utilisée par une autre fonction qu'en la passant comme argument de la fonction (voir le chapître sur les fonctions pour plus de précisions). Il faut faire attention au fait que si l'on déclare une variable locale avec un nom identique à celui d'une variable globale, c'est la variable locale qui est lue ou modifiée. Une erreur courante est de re-déclarer en local une variable globale, qui n'est ainsi pas modifiée comme prévu.

Déclarations

En langage C, il faut impérativement déclarer toutes les données que l'on va utiliser, avec le type de chaque donnée. Ceci permet à la machine de savoir quelle quantité de mémoire elle doit réserver à chaque variable (il ne faut pas la même quantité de mémoire pour représenter un caractère ou un réel) ainsi que la façon de les représenter. Par exemple

int main (void) {
    float m, a, force ;
    m = 2.0 ;       /* masse */
    a = 4.0 ;       /* accélération */
    force = m * a ; /* force */
    printf ("%f\n", force) ; /* écrire le produit m*a a l'écran */
    return 1 ;
}

Dans cet exemple, on utilise trois variables réelles (type float) qui sont déclarées au début du programme. La déclaration des variables se fait en indiquant le type des variables, suivit des noms des variables de ce type, séparées par des virgules, la ligne est terminée par un point-virgule. Ensuite on assigne des valeurs à ces variables à l'aide de l'opérateur = (toujours le point-virgule à la fin).

Pour les deux premières, on a directement assigné des valeurs numériques (2.0 et 4.0 qui ne sont pas équivalents à 2 et 4, ces derniers étant des entiers). Pour la troisième, on lui a assigné le produit (*) des deux premières.

Enfin le résultat de ce produit est affiché à l'écran, à l'aide de l'instruction printf (voir entrées/sorties).

Affichage/lecture de variables avec printf/scanf

Pour demander la valeur d'une variable à l'utilisateur, ou pour afficher la valeur d'une variable à l'écran, on utilise les fonctions scanf() et printf(), qui sont décrites dans le chapître sur les entrées/sorties.

Exemples

Affichez, compilez et exécutez les programmes suivants :

prog2.c : déclaration et utilisation de variables

prog3.c : déclaration et utilisation de variables : fonctions mathématiques

Auteur(s) : Anciens, A. Daerr. Dernière modification : Tue Nov 21 00:53:11 2006. [validate XHTML]