Programmation : C


Sommaire
Linux
Programmation
Divers logiciels
News à venir
CV

Mail me




 
 
 
Introduction
Types de base
Déclaration des variables
La déclaration,
Convention en usage,
Les classes d'allocation,
Les différentes classes de variables,
Variables locales - Classe auto par défaut,
Variables locales à un bloc - Classe auto par défaut,
Variables locales - Classe register,
Variables locales - Classe static,
Variables globales - Classe static par défaut,
Variables globales - Classe extern,
Initialisation de variables lors de leurs déclaration,
Variables non modifiables.
Les énumérations
Constantes et macro-constantes
Définition de types
Les Expressions
Introduction au C    
Déclaration des variables    
 
   
Déclaration d'une variable: type + nom

type liste_var_de_ce_type ;

Identificateurs corrects: Identificateurs incorrects:
TAILLE
8adr
Buffer
a b
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.

Haut de la page

Conventions en usage

i, j, k, ... pour les indices de boucle
p, q, p1,... pour les identificateurs de pointeurs
s pour une variable de type chaîne de caractères
tmp pour une variable temporaire,...
donnez aux variables un nom mnémonique, supprimez les noms du style style toto1, toto2,... comme les noms trop compliqués à retenir: prmpt qui pourrait vouloir signifier "premier point".
rendre lisibles les identificateurs comprenant plusieurs mots par le caractère "_" ou par une majuscule sur les débuts des mots: premier_point ou premierPoint.
ne vous limitez pas sur le nombre de caractères par identificateur
commentez chaque définition de variable
les variables débutant par le symbole souligné _ sont habituellement réservées au système

Voir d'autres conseils pour nommer les variables page 105 de ce document.

Haut de la page

Les classes d'allocation

Où effectuer la déclaration ?
à l'extérieur des fonctions = variables globales et externes
entre la définition d'une fonction et son corps = variables locales
au début d'une instruction composée = variables locales

Les différentes classes de variables
variables locales (classe auto par défaut)
variables locales (classe register)
variables locales (classe static)
variables globales (classe static par défaut)
variables globales externes et fonctions externes (classe extern)

Haut de la page

Variables locales - classe auto par défaut

int calcul (double x)
{		    
  int i;
while (i > 0)
...
 Visibilité de la variable i
}    



void main (void)
{		    
  int i ;
int j ;
for (i=1 ; ...
...
j += i ;
 Visibilité des  variables i et j
}    

Variable automatique(variable temporaire, variable locale)
fait partie de l'environnement local d'une fonction
n'est visible que dans le bloc concerné
allouée dans la pile lors de l'exécution
n'existe que pendant l'exécution du bloc

Haut de la page

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)
{
int i ;
...
i = 3 ;
{
int j ;
...
for (j = 0 ; i <= n ; ...
...
}
}

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é.

Haut de la page

Variables locales - classe register
int calcul (int x)
{		    
  register int i ;
register int j = 0 ;

for (i = 0 ; i <= x ; i++)
j += 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.
 
 
Haut de la page
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).
 
Exemple:

int lecture (int a)
{		    
  static int i = 0 ;
int j = 0 ;

j += i ;
i++ ;
...		 Visibilité des
variables i et j
}    



Variable locale static
fait partie de l'environnement local d'une fonction
l'emplacement mémoire est alloué lors de la compilation du programme et demeure inchangé durant son exécution

Haut de la page

Variables globales - classe static par défaut

int s1 ;
int calcul (int a)
{
if (a > s1)
s1++ ;
return(s1) ;
}
void main (void)
{
...
s1 = 25 ;
...
} 		Visibilité de

      la variable s1

Variable globale
fait partie de l'environnement du fichier, donc de toutes les fonctions définies dans le fichier; toutes les fonctions peuvent modifier cette variable et le buggage devient difficile.
l'emplacement mémoire est alloué lors de la compilation du programme et demeure inchangé durant son exécution.

Haut de la page

Variables globales - classe extern
 fichier arbre.c
 fichier calcul.c
int E1 ;

void main (void)
{
...
E1 = 25 ;
...
} 		extern int E1 ;

float calcul (int a)
{
...
if (a > E1)
...
}

Variable globale externe
fait partie de l'environnement de chaque fichier qui inclu sa déclaration, toutes les fonctions de ces fichiers peuvent donc modifier cette variable et compliquer le débuggage.
l'emplacement mémoire est alloué lors de la compilation du fichier dans lequel la variable est déclarée (sans extern), les références externes à cette variable dans les autres fichiers sont effectués lors de l'édition de liens.

Par convention:
toutes les variables locales s'écrivent en lettres minuscules, toutes les variables globales commencent par une lettre majuscule.

Haut de la page

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)
{
float x ;
int y ;
...
.x = calcul(y) ; <--- appel de la fonction
}

float calcul (int a)
 <--- définition du code (instructions) de la fonction
{
if (a > s1)
...
}

Haut de la page

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 ;

unsigned short heure = 60 * 60 ;
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:
char nom[TAILLE] ;
char *adresse_dernier_element = nom + TAILLE - 1 ;
se traduisent par :
réservation d'une zone de TAILLE octets consécutifs,
association du nom symbolique nom à l'adresse de début de la zone mémoire réservée,
réservation d'une zone de 4 octets permettant de stocker une adresse,
association du nom symbolique adresse_dernier_element à l'adresse de cette zone mémoire,
calcul de la constante nom + TAILLE - 1 (qui est bien l'adresse du dernier élément du tableau nom),
stockage de cette valeur dans la variable adresse_dernier_element. L'initialisation des tableaux est présentée page 53


Initialisation d'une variable temporaire
initialisation effectuée lors de l'allocation mémoire de la variable, lors de chaque appel de la fonction dans laquelle elle est définie
par une expression quelconque (et non par une expression constante)
int calcul (int a)
{
int b = 2 * a ;

Haut de la page

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 ;
char nom[n] /* incorrect */

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.

Haut de la page

Langage C Partie I: Déclaration des variables
   

Site modifié le 03/02/2003
Réalisé en 1999-2002, avec : Macromedia DreamWeaver 4.01
par
SGD