Les termes suivants font partie du vocabulaire couramment utilisés
dans le contexte du développement en langage C (mais pas seulement).
Pour une pratique raisonnable, il convient d'en connaître la signification.
L'emplacement où se situe une donnée dans la mémoire.
Les adresses sont manipulées avec les types pointeurs.
La propriété d'un type qui contraint l'adresse qu'une donnée peut occuper
en mémoire.
Les propriétés d'alignement des différents types varient d'une plateforme
d'exécution à une autre.
Le compilateur en a connaissance et choisit le placement des données en
conséquence.
Le procédé qui consiste à réclamer explicitement au système d'exploitation
un bloc d'octets de taille choisie afin que le programme en fasse l'usage
qui lui convient.
Un tel bloc devra être explicitement libéré.
Une construction du langage qui conditionne l'exécution d'un nombre
quelconque de portions de code à l'évaluation unique de la valeur
entière d'une expression.
Les mots-clefs switch, case et default matérialisent
cette alternative.
Une construction du langage qui conditionne l'exécution d'une ou deux
portions de code à la valeur logique d'une expression.
Les mots-clefs if et else matérialisent cette alternative.
Une table de conversion standard entre des codes numériques et des
caractères textuels.
L'ensemble des fonctionnalités dédiées à des tâches usuelles, déjà compilées
et livrées telles quelles lors de l'installation du compilateur sur le
système d'exploitation.
Tout programme a implicitement accès à ces fonctionnalités, à condition
d'inclure les fichiers d'en-tête standards.
Un chiffre binaire (binary-digit).
Un bit ne peut valoir que 0 ou 1 et est souvent interprété
comme une puissance de deux selon sa position dans une séquence.
Un octet est constitué de huit bits.
Une opération sur des entiers qui ne les considère pas pour leur valeur
arithmétique mais qui effectue des opérations logiques sur les bits
qui les constituent.
Une paire d'accolades contenant des déclarations et des instructions.
Les blocs de code limitent la portée des identificateurs qui y sont déclarés.
Une construction du langage qui conditionne la répétition d'une portion de
code à la valeur logique d'une expression qui est évaluée avant chaque
nouvelle itération.
Le mot-clef while matérialise cette boucle.
Une construction du langage qui conditionne la répétition d'une portion de
code à la valeur logique d'une expression qui est évaluée après chaque
nouvelle itération.
Les mot-clefs do et while matérialisent cette boucle.
Une construction du langage qui détermine la répétition d'une portion de
code selon un compteur.
Le mot-clef for matérialise cette boucle (mais il permet d'exprimer
d'autres formes de boucles).
La plus petite entité adressable (que l'on peut désigner pour y lire ou
y écrire) dans la mémoire.
Dans la pratique, bien que rien ne l'impose, il s'agit généralement
d'un octet.
Le caractère qui est placé en dernière position d'une chaîne pour en marquer
la fin.
Son code ASCII vaut zéro et il est usuellement représenté par la constante
littérale '\0'.
Le terme anglais usuellement employé pour l'opération de coercition.
Un tableau contenant une séquence de caractères terminée par le caractère
nul.
Une chaîne sert à représenter du texte.
Une propriété des variables qui fait qu'elles apparaissent automatiquement à
l'entrée dans un bloc de code (une fonction par exemple) et qu'elles
disparaissent à sa sortie.
Les variables automatiques ont une valeur initiale indéterminée si on ne
les initialise pas explicitement.
Une propriété des variables qui fait qu'elles existent pendant toute la
durée du programme.
Les variables globales (déclarées à l'extérieur de toute fonction) et les
variables à portée locale mais précédées du mot-clef static ont une
classe de stockage statique et ont une valeur initiale nulle si on ne
les initialise pas explicitement.
Ce qui doit être produit par une règle de fabrication d'un fichier
makefile.
Il s'agit généralement d'un fichier objet ou d'un programme exécutable.
L'action de convertir explicitement un type de donnée vers un autre.
Sa forme consiste à faire précéder une expression par le nom du type visé
entre parenthèses.
La commande spécifiée dans un fichier makefile qui doit être invoquée
pour générer une cible à partir de ses prérequis.
Il s'agit généralement de provoquer une compilation ou une édition de liens.
L'outil informatique chargé de réaliser la compilation.
Les outils gcc ou cl.exe par exemple sont des compilateurs.
L'action de traduire un code source exprimé en langage C vers un format
exécutable que le système d'exploitation et la machine informatique
comprennent.
Une construction à base de directives du préprocesseur faisant en sorte
qu'une partie du code source soit prise en compte ou bien ignorée.
Un usage très courant consiste à proposer pour une même fonctionnalité
plusieurs formulations qui concernent chacune une plateforme d'exécution
différente.
La démarche qui consiste à répartir le code source d'un programme en de
multiples modules compilés séparément.
Pour une application conséquente, cela permet un gain de temps sur sa
fabrication en ne recompilant que les modules qui ont été modifiés.
La convention pour représenter les valeurs négatives des entiers qui
permet de leur appliquer les opérations arithmétiques usuelles de la
même façon qu'avec les valeurs entières positives.
Une expression dont on ne retient que la valeur logique pour prendre une
décision.
En langage C toute valeur nulle (quel que soit son type) est considérée
comme fausse et toute autre valeur non-nulle (quelle qu'elle soit) est
considérée comme vraie.
L'ensemble des données qui étaient accessibles juste avant l'appel à
une fonction.
Il n'est pas directement accessible depuis le contexte de la fonction appelée.
L'écriture du prototype d'une fonction suivi d'un point-virgule.
À défaut d'une définition, une telle déclaration doit être connue du
compilateur afin qu'un appel à cette fonction puisse être exprimé.
L'écriture du prototype d'une fonction suivi d'un bloc de code qui
constitue son algorithme.
Un programme n'est pas complet s'il contient des appels à des fonctions qui
ne sont pas définies.
L'outil informatique qui permet d'inspecter un programme pendant son
exécution.
Il sert principalement à investiguer lorsqu'une erreur se manifeste pendant
le fonctionnement du programme.
L'outil gdb est un débogueur ; il existe de multiples interfaces
graphiques pour en présenter les informations.
L'action d'accéder à la donnée désignée par un pointeur.
L'intention peut être de la modifier ou de la consulter.
Le symbole * matérialise cette opération.
Une construction du code source destinée à être interprétée par le
préprocesseur.
Les directives commencent par le symbole #.
L'outil informatique chargé de réaliser l'édition de liens.
Les outils ld ou link.exe par exemple sont des éditeurs de
liens.
Cet outil est généralement invoqué automatiquement par le compilateur.
La dernière étape de la fabrication d'un programme exécutable qui consiste
à rassembler les modules compilés séparément.
Cette étape vérifie notamment que les multiples modules ne définissent
qu'une seule fois chaque fonction du programme et qu'il n'en manque pas.
L'effet qui peut être produit par l'évaluation d'une expression mais qui
n'est pas son résultat.
L'affichage d'un message ou la modification d'une donnée en mémoire sont
des effets secondaires.
Nous rencontrons de manière très courante en Français le terme “effet
de bord” qui n'est rien d'autre qu'une très mauvaise traduction du terme
Anglais “side-effect”.
La démarche qui consiste à définir une structure de données et l'ensemble
des fonctions qui décrivent le jeu d'opérations usuelles qui ont du sens
pour ce type.
Les fonctions en question forment l'unique interface de programmation pour
ce type.
L'erreur qui se produit lorsqu'un programme tente d'utiliser une zone de la
mémoire qui lui est inaccessible.
Une telle erreur est émise par le système d'exploitation et termine
brutalement le programme.
L'ensemble des adresses qui peuvent être désignées par un pointeur.
L'étendue de la mémoire effectivement disponible sur une plateforme
d'exécution est généralement bien moins vaste.
Une formulation dont l'évaluation doit produire un résultat.
En langage C il n'y a pas de distinction entre les expressions
arithmétiques et logiques.
Un fichier contenant essentiellement des déclarations de types et de
fonctions.
Dans le cadre de la démarche de compilation séparée, de tels fichiers
sont inclus dans le code source afin d'avoir accès aux déclarations
de fonctions qui sont définies dans d'autres modules.
Le nom d'un fichier d'en-tête a généralement une extension .h
(pour header).
Un fichier d'en-tête qui est livré avec la bibliothèque standard à
l'installation du compilateur.
Il en existe de nombreux ; ce document exploite ceux-ci :
#include <ctype.h>
—
character types
#include <float.h>
—
floating types
#include <limits.h>
—
implementation-defined constants
#include <math.h>
—
mathematical declarations
#include <stdbool.h>
—
boolean type and values
#include <stddef.h>
—
standard type definitions
#include <stdint.h>
—
integer types
#include <stdio.h>
—
standard buffered input/output
#include <stdlib.h>
—
standard library definitions
#include <string.h>
—
string operations
Un fichier décrivant toutes les étapes permettant d'obtenir un programme
exécutable à partir de ses fichiers de code source.
Un tel fichier est exploité par la commande make.
Le fichier qui est obtenu en compilant le code source d'un module mais sans
aller jusqu'à l'édition de liens.
L'éditeur de lien rassemble les multiples fichiers objets pour produire
le programme exécutable.
Une donnée d'un type élaboré (structure) qui est reliée à un moyen de
communication (fichier, terminal...), qui permet d'en connaître l'état et
qui propose des fonctionnalités de formatage.
Les fichiers et les entrées-sorties standards sont généralement manipulés
par des flux.
La fonction qui est automatiquement appelée lorsque le programme démarre
et qui met fin au programme lorsqu'elle se termine ; c'est le point
d'entrée du programme.
La fonction main() est la fonction principale d'un programme en
langage C.
Le fait qu'un programme ne libère pas des blocs mémoire qu'il a obtenus
dynamiquement bien qu'il n'en ait plus besoin.
Cette situation peut causer l'épuisement de la mémoire disponible dans
le système.
Le nom qui est donné à quelque chose d'identifiable dans le langage.
Ce nom peut désigner une fonction, une variable, un type...
L'opération qui consiste à accéder à un élément d'un tableau en spécifiant
un indice.
L'intention peut être de modifier ou de consulter cet élément.
Les symboles [ et ] matérialisent cette opération.
Un entier utilisé pour désigner un élément particulier parmi tous ceux
qui constituent un tableau.
La pratique qui consiste à ne pas manipuler directement une donnée par une
variable mais à travers un pointeur.
De multiples niveaux d'indirection peuvent être imbriqués.
La moindre action qui puisse être exécutée.
Un programme est une séquence d'instructions.
L'action qui consiste à rendre au système d'exploitation un bloc d'octets
obtenu par allocation dynamique.
Un programme doit libérer un tel bloc dès qu'il n'en a plus besoin afin qu'il
redevienne disponible pour un autre usage dans le système.
La construction qui permet d'énumérer, lors de sa déclaration, les valeurs
que doit contenir un tableau.
Les symboles
{ et
, et
}
matérialisent cette construction.
Une expression que l'on peut retrouver comme opérande gauche (left-value)
d'une opération d'affectation afin d'accueillir un résultat.
C'est le cas d'une simple variable, du déréférencement d'un pointeur ou
encore d'un élément d'un tableau.
Une directive du préprocesseur qui substitue dans le code source un unique
mot (éventuellement accompagné de paramètres) par un texte quelconque.
Les macros (en raccourci) servent souvent à nommer des constantes
littérales.
Une valeur entière dont les bits sont positionnés explicitement afin
de la combiner avec une autre valeur entière dans une opération
bit-à-bit.
Ceci permet notamment d'isoler quelques bits de cette autre valeur,
d'en forcer à 0 ou bien à 1.
Une des variables constitutives d'une structure de données.
La structure peut être considérée comme un tout, ou bien chacun de ses
membres peut être manipulé séparément.
Un fichier de code source réalisant un ensemble de fonctionnalités sur un
même thème.
De multiples modules constituent une application ; ils sont compilés
séparément.
Un ensemble de huit bits.
Un octet peut être vu comme un petit entier permettant de distinguer
deux-cent-cinquante-six valeurs différentes.
L'étape de la compilation qui consiste à simplifier et réordonner les
instructions que la machine informatique devra exécuter afin que
l'exécution d'un traitement soit la plus rapide possible tout en
restant conforme aux algorithmes exprimés dans le code source.
La dénomination alternative pour l'opérateur ternaire.
Un opérateur composé de trois opérandes : une condition, une expression à
évaluer si la condition est vérifiée, une autre expression à évaluer
sinon.
Le résultat de cet opérateur est le résultat d'une des deux
expressions dont il est composé.
Les symboles ? et : matérialisent cet opérateur.
La valeur qui est effectivement transmise comme paramètre lors de l'appel
d'une fonction.
C'est le résultat de l'évaluation d'une expression.
Le nom et le type d'un paramètre qui est attendu par une fonction.
Il est initialisé à l'entrée de la fonction par une copie du paramètre
effectif.
La démarche qui consiste à suspendre l'exécution du programme après chaque
ligne de code lors d'une session de débogage.
Cela permet d'investiguer les conditions de réalisation et les effets de
chacune d'elles lors de la recherche d'une erreur d'exécution.
La pratique qui consiste à utiliser un pointeur comme paramètre formel
d'une fonction et à fournir comme paramètre effectif l'adresse d'une
donnée afin qu'elle puisse être modifiée par cette fonction.
L'adresse en question est bien transmise par valeur ; ce n'est qu'une
émulation d'un passage par référence.
Le fait que le paramètre formel d'une fonction soit confondu avec le
paramètre effectif ; la modification du premier modifie également
ce dernier.
Ce mode de passage de paramètre n'existe pas en langage C et doit être
émulé par un passage par adresse.
Le fait que le paramètre formel d'une fonction ne manipule qu'une copie
du paramètre effectif ; la modification du premier n'a aucune influence
sur ce dernier.
C'est l'unique mode de passage de paramètre en langage C .
La zone de l'espace d'adressage qui permet de contenir les données
associées aux appels de fonctions (stack en anglais).
On y trouve notamment les paramètres et les variables de classe de stockage
automatique des fonctions.
Une ligne de code désignée dans un débogueur pour que l'exécution soit
suspendue lorsqu'elle est atteinte.
Un point-d'arrêt permet d'atteindre rapidement une zone de code digne
d'intérêt lors d'une session de débogage.
Un type de donnée qui permet de mémoriser l'adresse d'une autre donnée.
Le type d'un pointeur détermine l'interprétation qui pourra être faîte de
la donnée qui est située à cette adresse.
Un pointeur qui mémorise l'adresse 0 afin de signifier qu'il ne
désigne aucune donnée utile.
La macro NULL peut être utilisée pour une telle initialisation.
Une propriété des identificateurs qui fait que leur visibilité est étendue
à l'ensemble du code.
Tout ce qui est déclaré à l'extérieur de toute fonction (variable, type,
fonction...) a une portée globale.
Une propriété des identificateurs qui fait que leur visibilité est limitée
au bloc de code englobant.
Tout ce qui est déclaré à l'intérieur d'une fonction ou d'un bloc
(variable, type...) a une portée locale.
L'étape de la compilation qui consiste à modifier à la volée le code source
que le compilateur analysera effectivement.
Des directives permettent de spécifier ces transformations lexicales.
Ce qui est nécessaire à la production d'une cible par une règle de
fabrication d'un fichier makefile.
Dans le cas où la cible est un fichier objet, il s'agit d'un fichier de
code source et des fichier d'en-tête qu'il inclut.
Dans le cas où la cible est un programme exécutable, il s'agit de
l'ensemble des fichiers objets dont il doit être constitué.
La description de l'interface d'une fonction ; il s'agit du nom de la
fonction accompagné de la liste de ses paramètres avec leurs types et
de son type de retour.
L'action de relever l'adresse d'une donnée afin de la mémoriser dans un
pointeur.
Le symbole & matérialise cette opération.
Une formulation dans un fichier makefile qui rassemble une cible, ses
prérequis et la commande qui permet de produire la cible.
La cible est régénérée par l'exécution de la commande à chaque fois que
les prérequis sont modifiés.
Un type librement défini pour représenter l'agglomération de plusieurs
variables de types variés.
Une structure est généralement associée à un ensemble de fonctions qui
définissent le jeu d'opérations usuelles qui ont du sens pour ce nouveau
type.
Un type pour représenter une séquence de données ayant toutes le même type
et qui sont désignées par une unique variable.
Un indice permet d'en distinguer les éléments.
La zone de l'espace d'adressage dans laquelle le système d'exploitation
puise pour assurer l'allocation dynamique de mémoire
(heap en anglais).
L'opération qui consiste à remplacer des portions de code source par
d'autres sans se soucier de la signification de ce texte pour le
langage.
Le préprocesseur est dédié à de telles transformations.
Un type dont nous ne connaissons que le nom mais pas les détails.
Il ne peut être désigné que par des pointeurs qui sont passés à des
fonctions spécialisées dans l'usage de ce type (et qui, elles, en
connaissent les détails).
Les flux standards (type FILE) sont des types opaques.
L'ensemble du code qui est analysé par le compilateur lorsqu'il produit
un unique fichier objet.
Il s'agit du fichier de code source (.c) et de tous les fichiers
d'en-tête (.h) qu'il inclut.
Un message d'avertissement qui est produit par le compilateur pour signaler
une construction qui, sans être strictement interdite, est une source
d'erreur ou d'ambiguïté probable.
Si un tel message n'empêche pas la compilation, il faut néanmoins l'analyser
avec attention et chercher à l'éliminer.
LANG-C 13_Misc — Informations diverses