« Programmation C/Classe de stockage » : différence entre les versions

Contenu supprimé Contenu ajouté
Alveric (discussion | contributions)
m + noinclude
Tavernierbot (discussion | contributions)
m Bot: Retouches cosmétiques
Ligne 4 :
Il est possible de construire des types dérivés des types de base du langage en utilisant plusieurs combinaisons, deux étant illustrées dans ce chapitre: les classes de stockage et les qualificateurs.
 
== Classe de stockage ==
 
Le langage C permet de spécifier, avant le type d'une variable, un certain nombre de classe de stockage :
Ligne 14 :
Une variable, ou un paramètre de fonction, ne peut avoir qu'au plus une classe de stockage.
 
=== Classe 'auto' ===
Cette classe ne sert qu'à maintenir une certaine compatibilité avec le prédécesseur du C : le langage B. Car en fait, ce dernier ne comportait aucune notion de type, mais uniquement de classe. Comme il fallait bien mettre un mot-clé avant la définition d'une variable, celui-ci servait de passe-partout. En C, ce mot-clé sert pour les variables locales à une fonction, dites aussi ''automatiques''. Mais, une variable déclarée localement à une fonction étant implicitement automatique, ce mot-clé est inutile en C.
 
=== Classe 'register' ===
Indique que la variable devrait être stockée dans un registre du processeur. Les registres du processeur sont forcément limités, aussi bien en nombre qu'en taille. Inutile de déclarer une structure entière ou un tableau avec le mot clé <code>register</code>.
 
Ligne 33 :
</pre>
 
=== Classe 'static' ===
L'effet de la classe 'static' dépend de l'endroit où l'objet est déclaré :
* ''Objet local à une fonction'' : la valeur de la variable sera persistante entre les différents appels de la fonction. C'est une sorte de variable globale privée. L'intérêt de déclarer la variable à l'intérieur de la fonction est de garantir une certaine encapsulation, afin d'éviter des « optimisations » (usages multiples) d'une variable globale. Qui plus est, cela permet d'avoir plusieurs fois le même nom, dans des fonctions différentes.
Ligne 40 :
Les paramètres des fonctions ne peuvent être déclarés 'static'.
 
=== Classe 'extern' ===
 
<code>extern</code> permet de déclarer une variable sans la définir. C'est utile lorsqu'elle est définie dans un autre fichier. Toutes variables globales, autres que celles déclarées <code>static</code>, sont accessibles avec ce mot-clé.
Ligne 55 :
Une variable, ou un paramètre de fonction, peut avoir aucun, un, deux, ou les trois qualificateurs (certaines combinaisons n'auraient que peu de sens, mais sont autorisées).
 
=== Qualificateur 'const' ===
La classe <code>const</code> ne déclare pas une vraie constante, mais indique au compilateur que la valeur de la variable ne doit pas changer. Il est donc impératif d'assigner une valeur à la déclaration de la variable, sans quoi toute tentative de modification ultérieure entrainera une erreur de la part du compilateur :
 
Ligne 61 :
const int i = 0;
 
i = 1; /* erreur*/
</pre>
 
Ligne 78 :
char * const pointeur = "Salut tout le monde !";
 
pointeur = "Hello world !"; /* erreur*/
</pre>
 
Ligne 85 :
const char * const pointeur = "Salut tout le monde !";
 
pointeur = "Hello world !"; /* erreur*/
pointeur[0] = 0; /* erreur*/
</pre>
 
Cette dernière forme est néanmoins rarement usitée. En outre ce dernier exemple présente un autre problème qui est la modification d'une chaine de caractères « en dur », qui sont la plupart du temps placées dans la section lecture seule du programme et donc inaltérables.
 
=== Qualificateur 'volatile' ===
Ce mot-clé sert à spécifier au compilateur que la variable peut être modifiée à son insu. Cela annule toute optimisation que le compilateur pourrait faire, et l'oblige à procéder à chaque lecture ou écriture dans une telle variable tel que le programmeur l'a écrit dans le code. Ceci sert par exemple pour les coordonnées d'un pointeur de souris qui seraient modifiées par un autre programme, ou pour de la programmation avec de multiples fils d'exécution qui doivent communiquer entre eux, ou pour désigner des registres matériels qui peuvent être accédés depuis un programme C (une horloge, par exemple), mais dont la valeur peut changer indépendemment du programme.