type liste_var_de_ce_type ;
| Identificateurs corrects: | Identificateurs incorrects: |
| TAILLE | 8adr |
|---|---|
| Buffer | |
| i | |
| adresse_tableau | |
| j45 | |
| _ptr |
Un identificateur est un suite de lettres et de chiffres commençant par une lettre. Le symbole (caractère souligné) est considéré comme une lettre, on réserve son utilisation en premier caractère pour les variables systèmes.
Le compilateur différencie les lettres minuscules et majuscules.Conventions en usage:
Voir d'autres conseils pour nommer les variables page 105 de ce document.i, j, k, ... pour les indices de boucle
Les classes d'allocation:
Où effectuer la déclaration ?
Les différentes classes de variables:
Variables locales - classe auto par défaut:
int calcul (double x)
{void main (void)}
while (i > 0)
...
-------------------------------------------
Visibilité de la variable i
-------------------------------------------
{}
int j ;
for (i=1 ;
...
j += i ;
----------------------------------------
Visibilité des variables i et j
----------------------------------------
Variable automatique: (variable temporaire, variable locale)
Variables locales à un bloc - classe auto par défaut:
Il est tout à fait possible de limiter la portée d'une variable locale à un petit groupe d'instructions (appelé alors bloc) - Par exemple :
void main(void){La portée de la variable j est limitée au bloc dans lequel cette variable est déclarée. L'imbrication des blocs permet de déclarer des variables de même nom, seule la variable de niveau le plus profond est alors accessible dans un bloc donné.
int i ;
i = 3 ;
{int j ;}
...
for (j = 0 ; i <= n ; ...
}
Variables locales - classe register:
int calcul (int x)
{
register int i ; |
|
------------------------------------ Visibilité des variables i et j ------------------------------------ |
Les registres étant d'accès beaucoup plus rapide qu'une variable rangée en mémoire centrale, il est avantageux de placer les variables très souvent accédées dans des registres. La requête de l'utilisateur ne pourra cependant être satisfaite que s'il reste des registres disponibles lors de l'exécution du programme.
Toutefois, l'amélioration des performances des optimiseurs de code rend obsolète cette classe de variable.
Variables locales - classe static:
La classe static utilisée dans un bloc permet de stocker
de façon permanente des données à l'usage exclusif
de ce bloc (ici d'une fonction).
La variable ainsi définie n'est ni construite lors de l'appel
de la fonction, ni détruite lors du retour de la fonction.
À chaque appel de la fonction, la variable i retrouve sa valeur
précédente, d'où la nécessité de
l'initialiser lors de sa déclaration par : int i = 0 ;
Il n'existe qu'un seul exemplaire de la variable : faire attention
lors des retours des fonctions (voir slide 79).
int lecture (int a)
{
static int i = 0 ; |
|
------------------------------------------- Visibilité des variables i et j ------------------------------------------- |
Variable locale static:
Variables globales - classe static par défaut:
Variable globale:
int s1 ;
int calcul (int a){void main (void)
if (a > s1)s1++ ;}
return(s1) ;{
...
S1 = 25 ;
...
}-------------------------------------------
Visibilité de
la variable s1
-------------------------------------------
Variables globales - classe extern:
fichier arbre.c: fichier calcul.c:
| int E1 ; void main (void) { |
extern int E1 ; float calcul (int a) { |
Par convention: toutes les variables locales s'écrivent en lettres minuscules, toutes les variables globales commencent par une lettre majuscule.
Fonction externe:
La fonction extern permet de séparer la déclaration du profil d'une fonction de sa définition dans le même fichier ou des fichiers séparés:
| extern float calcul (int a) ; | <--- déclaration du profil de la fonction |
void main (void)
-..-..-..-..-..-..-..-..-..-..-..-..-..-..-..-..-..-..-..-..-..-..-..-..-..-..-..-..-..-..-..-..-..-x = calcul(y) ;
{
float x ;
int y ;...<--- appel de la fonction
}
| float calcul (int a) de la fonction |
<--- définition du code (instructions) |
{
if (a > s1)
...
}
L'initialisation de variables lors de leur déclaration:
initialisation d'une variable permanente (static) par une valeur connue lors de la compilation:
int nb = 0 ;
char c=- 'a' ;
float e = 2.71828 ;
int *adresse = &nb ;
char nom[TAILLE] ;
char adresse_dernier_element = nom + TAILLE - 1 ;
Le compilateur traite les déclarations et les initialisations séquentiellement.
Par exemple, les deux dernière déclarations:
se traduisent par :char nom[TAILLE] ;
char *adresse_dernier_element = nom + TAILLE - 1 ;
L'initialisation des tableaux est présentée page 53
Initialisation d'une variable temporaire:
int calcul (int a)
{int b = 2 * a ;
Les variables non modifiables..
L'attribut const placé devant une déclaration prévient le compilateur que cette variable ne peut pas être modifiée par une instruction du programme.
Une telle variable n'est pas réellement considérée comme une constante, mais plutôt comme une variable non modifiable. Par exemple, on ne peut pu utiliser une telle variable pour dimensionner un tableau :const int n = 10 ;Ce mécanisme peut également être utilisé lors du passage des arguments dans une fonction: la déclaration d'un argument peut être précédée du mot clé const précisant ainsi que ce paramètre, qu'il soit une adresse ou une variable, ne peut pas être modifié par la fonction.
char nom[n] /* incorrect */
Langage C Partie I: Déclaration des variables