LESSON 2 : les variables et les constants

1-Les variables:

Le concept de variable

Une variable est un objet repéré par son nom, pouvant contenir
des données, qui pourront être modifiées lors de l'exécution du programme.
Les variables en langage C sont typées, c'est-à-dire que les données
contenues dans celles-ci possèdent un type, ainsi elles sont donc stockées dans la mémoire
et occupent un nombre d'octets dépendant du type de donnée stockée.

En langage C, les noms de variables peuvent être aussi long que l'on désire, toutefois
le compilateur ne tiendra compte que des 32 premiers caractères.
De plus, elles
doivent répondre à certains critères :

• un nom de variable doit commencer par une lettre (majuscule ou minuscule) ou un « _ » (pas par un chiffre)
• un nom de variable peut comporter des lettres, des chiffres et le caractère   

       « _ » (les espaces ne sont pas autorisés !)

• les noms de variables ne peuvent pas être les noms suivants (qui sont des noms réservés) :
  • auto
  • break
  • case, char, const, continue
  • default, do, double
  • else, enum, extern
  • float, for
  • goto
  • if, int
  • long
  • register, return
  • short, signed, sizeof, static, struct, switch
  • typedef
  • union, unsigned
  • void, volatile
  • while

Les noms de variables sont sensibles à la casse (le langage C fait la différence entre
un nom en majuscules et un nom en minuscules), il faut donc veiller à

utiliser des noms comportant la même casse !

La déclaration de variables

       Pour pouvoir utiliser une variable, il faut la définir, c'est-à-dire lui  donner un nom, mais surtout un type de donnée à stocker afin qu'un  espace mémoire conforme au type de donnée qu'elle contient lui soit réservé.

Une variable se déclare de la façon suivante :

 type Nom_de_la_variable;

ou bien s'il y a plusieurs variables du même type :

 type Nom_de_la_variable1, Nom_de_la_variable2, ...;

Affectation d'une donnée à une variable

Pour stocker une donnée dans une variable que l'on a initialisée, il faut faire une affectation, c'est-à-dire préciser la donnée qui va être stockée à l'emplacement mémoire qui a été réservé lors de l'initialisation.

Pour cela on utilise l'opérateur d'affectation « = » :

Nom_de_la_variable = donnée;

Pour stocker le caractère B dans la variable que l'on a appelée Caractere,
il faudra écrire :

 Caractere = 'B';

Ce qui signifie stocker la valeur ASCII de « B » dans la variable nommée «caractere».
Il est bien évident qu'il faut avoir préalablement déclaré la variable en lui affectant
le type char :

 char Caractere;

Initialisation d'une variable

La déclaration d'une variable ne fait que « réserver » un emplacement mémoire où stocker la variable. Tant que l'on ne lui a pas affecté une donnée celle-ci contient ce qui se trouvait précédemment à cet emplacement, que l'on appelle garbage (en français détritus).

On peut donc affecter une valeur initiale à la variable lors de sa déclaration, on parle
alors d'initialisation :

 type Nom_de_la_variable = donnee;

Par exemple :

 float Toto = 125.36;

Portée (visibilité) des variables

Selon l'endroit où on déclare une variable, celle-ci pourra être accessible (visible) de partout dans le code ou bien que dans une portion confinée de celui-ci (à l'intérieur d'une fonction par exemple), on parle de portée (ou visibilité) d'une variable.

Lorsqu'une variable est déclarée dans le code même, c'est-à-dire à l'extérieur de toute fonction ou de tout bloc d'instruction, elle est accessible de partout dans le code (n'importe quelle fonction du programme peut faire appel à cette variable). On parle alors de variable globale.

Lorsque l'on déclare une variable à l'intérieur d'un bloc d'instructions (entre des accolades), sa portée se confine à l'intérieur du bloc dans lequel elle est déclarée.

• Une variable déclarée au début du code, c'est-à-dire avant tout bloc de donnée, sera globale, on pourra alors l'utiliser à partir de n'importe quel bloc d'instruction.
• Une variable déclarée à l'intérieur d'un bloc d'instructions (dans une fonction ou une boucle par exemple) aura une portée limitée à ce seul bloc d'instruction, c'est-à-dire qu'elle est inutilisable ailleurs ,on parle alors de variable locale. 

Les différents types de variables, leurs modificateurs, et leurs limites

En C, il existe deux familles de variables concernées par ce chapitre : les entiers, et les réels (souvent appelés "nombres en virgule flottante", communément abrégé en "flottants"). Ces deux familles sont découpées en plusieurs tailles, permettant de stocker des nombres plus ou moins grands.

A: Les entiers

1: Ce que dit la norme

Tout d'abord, précisons que l'écriture suivante :

sizeof(type)

renvoie la taille, en octets, que prend une variable du type précisé ; cela pourra nous servir dans la suite de ce chapitre. Je vous encourage d'ailleurs, lorsque vous avez besoin d'utiliser le nombre d'octets que fait un type de variables, à toujours employer sizeof plutôt que la taille que vous pensez que fait une variable. Ainsi, votre code sera plus facilement portable sur d'autres machines. (d'autant plus que la taille, en octet de chaque type n'est pas fixé par la norme !).
Sachez aussi que sizeof n'est pas réservé aux variables entières seulement.
La taille en octets des types de variables entières n'est pas fixé par la norme ANSI, ni par la norme GNU.
La seule chose qui est précisée, c'est que sizeof(char) doit être inférieure ou égale à sizeof(short), qui doit être inférieure à sizeof(int), qui doit être inférieure ou égale à sizeof(long), qui doit elle-même être inférieure ou égale à sizeof(long long), sachant que int correspond généralement au mot-machine.

2: Ce qu'il en est pour nos calculatrices

Maintenant que nous avons vu ce que dit la norme, voyons ce qu'il en est pour nos calculatrices, et ce que signifie les différents types énoncés ci-dessus.

Écriture complète	Écriture concise, généralement utilisée	Taille, avec les options par défaut	Intervalle de valeurs
signed char	char	8 bits, 1 octet	de –128 à 127
unsigned char	unsigned char	8 bits, 1 octet	de 0 à 255
signed short int	short	16 bits, 2 octets	de -32 768 à 32 767
unsigned short int	unsigned short	16 bits, 2 octets	de 0 à 65 535
signed int	int	16 bits, 2 octets	de -32 768 à 32 767
unsigned int	unsigned int	16 bits, 2 octets	de 0 à 65 535
signed long int	long	32 bits, 4 octets	de -2 147 483 648 à 2 147 483 647
unsigned long int	unsigned long	32 bits, 4 octets	de 0 à 4 294 967 296
long long int	long long	64 bits, 8 octets	de -9223372036854775808 à 9223372036854775807
unsigned long long int	unsigned long long	64 bits, 8 octets	de 0 à 18446744073709551615

B: Les flottants

Pour ce qui est des nombres flottants, la norme définit ceci : sizeof(float) doit être inférieure ou égale à sizeof(double), qui doit elle même être inférieure ou égale à sizeof(long double).

2-Les constants:

Définition de constantes

Une constante est une variable dont la valeur est inchangeable lors de l'exécution
d'un programme. En langage C, les constantes sont définies grâce à la directive du préprocesseur #define, qui permet de remplacer toutes les occurrences du mot qui le suit par la valeur immédiatement derrière elle. Par exemple la directive :

#define _Pi 3.1415927

Toutefois, avec cette méthode les constantes ne sont pas typées, il faut donc
utiliser la directive #define avec parcimonie...

Il est ainsi préférable d'utiliser le mot clef const, qui permet de déclarer des constantes typées :

const int dix = 10;