Initiation pragmatique au langage C

Nous allons étudier les mots et les symboles qui constituent le programme dans l'ordre de leur apparition.

int est un type. Ici, il qualifie la valeur retournée par la fonction.

main est un identificateur défini par l'utilisateur. Utilisé dans ce contexte, il désigne le nom de la fonction. Cet identificateur a cependant un sens particulier. Il désigne le point d'entrée du programme. Cela signifie qu'un programme C commencera toujours par un appel 'invisible' à la fonction main(). Cet appel provient de la séquence d'initialisation du programme. Les détails dépendent de l'implémentation, mais, d'une manière simplifiée, voici quel est le déroulement des opérations :

1. Chargement du logiciel ;
2. Exécution du code d'initialisation (« boot ») ;
3. Appel de l'application (CALL MAIN) ;
4. Exécution de l'application, jusqu'à la fin de main() ;
5. Exécution du code de fin ;
6. Retour au système.

void est un mot clé qui signifie 'rien' ou 'absence de'. Ici, il sert à indiquer que la fonction n'a pas de paramètres.

return est un mot clé qui signifie « quitter la fonction courante ». Si la fonction n'a pas de type de retour (type void) on peut utiliser return tout seul suivit d'un point-virgule. Sinon, il doit être suivi d'une valeur et d'un point-virgule. La valeur doit être du type qui a été défini pour la fonction. Cette valeur peut avoir un sens particulier. Il est d'usage de retourner 0 pour signifier que tout va bien (pas d'erreur) et une valeur autre que 0 pour signifier une erreur.

Le bit (BInary digiT) ou chiffre binaire est l'unité de mesure d'information. Il peut prendre 2 valeurs : 0 ou 1.

Le byte (ou multiplet) est le plus petit objet adressable pour une implémentation donnée. En langage C, il fait au moins huit bits.

Un caractère est une valeur numérique qui représente un glyphe visible ('A', '5', '*', etc.) ou non (CR, LF, etc.). Un caractère est de type int. Cependant, sa valeur tient obligatoirement dans un type char.

Un objet de la taille d'un byte peut recevoir la valeur de n'importe quel caractère.

Une chaîne de caractères est une séquence de caractères encadrée de doubles quotes.

"Hello world!"

La représentation interne d'une chaîne de caractères est spécifiée. C'est un tableau de char terminé par un 0.

char s[] = "Hello";

est équivalent à :

char s[] = {'H', 'e', 'l', 'l', 'o', 0};

Un comportement indéfini (encore appelé Undefined Behaviour ou UB) est un bug grave. Il signifie que le comportement du programme est imprévisible et que tout peut arriver, y compris, et c'est ça qui rend ce bug très dangereux, un comportement d'apparence conforme.

Il n'existe pas de moyen automatique de détecter tous les UB d'un programme. Seul un contrôle visuel fait par une personne chevronnée permet de détecter un tel bug.

Une fonction est une séquence d'instructions dans un bloc nommé. Une fonction est constituée de la séquence suivante :

• un type (ou le mot clé void) ;
• un identificateur (le nom de la fonction, ici main) ;
• une parenthèse ouvrante ( ;
• une liste de paramètres ou une liste vide (dans ce cas, on écrit void) ;
• une parenthèse fermante ) ;
• une accolade ouvrante { ;
• une liste d'instructions terminée par un point virgule ;, ou rien ;
• une accolade fermante }.

L'utilisateur peut créer ses propres fonctions. Une fonction peut appeler une autre fonction. Généralement, une fonction réalisera une opération bien précise. L'organisation hiérarchique des fonctions permet un raffinement en partant du niveau le plus élevé (main()) en en allant au niveau le plus élémentaire (atomique).

On gardera cependant en tête que la multiplication des niveaux introduit une augmentation de la taille du code et du temps de traitement.

Une fonction ne peut être appelée qu'à partir d'une autre fonction.

Un flux est un canal de données orienté byte. Il permet de réaliser des entrées ou des sorties de bytes, soit un par un, soit par bloc.

C'est le mécanisme du langage C qui permet l'interaction avec l'environnement.

Un programme C ouvre trois flux par défaut :

• stdin : le flux d'entrée standard ;
• stdout : le flux de sortie standard ;
• stderr : le flux de sortie d'erreur.

Sur la plupart des implémentations, ces flux sont connectés à la console.

La zone entre parenthèses d'une fonction peut recevoir des paramètres. Un paramètre est défini au minimum par un type et un identificateur.

Exemple :

int fonction (int x)
{
}

x est un paramètre de type int. Il est obligatoire, et la valeur passée doit être du même type.

...
{
   fonction (123);
}
     


...
{
   int a = 123;
   fonction (a);
}

Il faut savoir qu'en C, un paramètre ne fait que transmettre une valeur. Modifier la valeur d'un paramètre n'aura jamais d'effet sur la valeur originale. (la fonction printf() permet ici de visualiser le contenu des variables a et x) :

#include <stdio.h>
 
void fonction (int x)
{
   printf ("x = %d (dans la fonction)\n", x); /* x = 123 */
   
   x = 456;
   printf ("x = %d (dans la fonction)\n", x); /* x = 456 */
}

int main (void)
{
   int a = 123;

   printf ("a = %d\n", a); /* a = 123 */
   
   fonction (a);
   printf ("a = %d\n", a); /* a = 123 */
   return 0;
}

Après l'appel de la fonction, la valeur de 'a' est inchangée (123).

a = 123
x = 123 (dans la fonction)
x = 456 (dans la fonction)
a = 123

Le préprocesseur est un outil qui traduit certaines instructions du code source avant le compilateur. Les instructions du préprocesseur commencent par #. Par exemple #include.

printf() est une fonction standard de la bibliothèque du la bibliothèque du C. Elle est conçue pour émettre des chaînes de caractères formatées vers la sortie standard (stdout). Elle est déclarée dans le fichier d'entête <stdio.h>. Pour l'utiliser, on doit utiliser la directive #include <stdio.h>.

Cette puissante fonction permet de réaliser des affichages formatés. Sa description complète prendrait un chapitre entier. Voici donc quelques éléments de base.

Elle fonctionne selon un principe un peu particulier.

Son premier paramètre est une chaîne de caractères pouvant comporter des séquences spéciales commençant par « % ». Le caractère qui suit le « % » a une signification particulière. Certaines sont définies (%, d, i, f, s, c etc.), d'autres non. Le rôle est cette séquence de caractères est d'indiquer à printf() comment il doit interpréter les valeurs passées dans les paramètres suivants. Il doit y avoir correspondance, sinon, le comportement est indéfini.

IV-J-1. Les principaux formateurs de printf()▲

IV-J-2. Exemples d'utilisation de printf()▲

#include <stdio.h>
 
int main (void)
{
   printf ("%c\n", 'A');
   printf ("%d\n", 123);
   printf ("%d, '%c'\n", 'A', 'A');

   printf ("Hello world\n");
   printf ("Hello %s\n", "world");
   printf ("%s\n", Hello world);
   
   return 0;
}

A
123
65, 'A'
Hello world
Hello world
Hello world

Le prototype d'une fonction est une déclaration indiquant :

• le type du retour (ou void s’il n'y en a pas) ;
• le nom de la fonction ;
• la liste et le type des paramètres (ou void s’il n'y en a pas).

Un prototype peut être intégré à la fonction. Dans ce cas, il est confondu avec la première ligne de la fonction :

int function (void)
{
   /* ... */
   return 0;
}

Il peut aussi être détaché (séparé) de la fonction. Dans ce cas, il doit être suivi d'un ';'.

int function (void);

L'opérateur unaire sizeof retourne la taille d'un objet en bytes. Le paramètre de sizeof peut être un objet ou un type. Si c'est un type, celui-ci doit être placé entre parenthèses. Le type retourné par sizeof est size_t (entier non signé). L'expression est une constante évaluée à la compilation.

size_t est un type standard défini dans <stddef.h>.

#include <stddef.h>

size_t size_of_an_int = sizeof (int);

double n;

size_t size_of_n = sizeof n;

Un tableau est une suite d'objets identiques consécutifs.

/* Définition d'un tableau de 10 char */
char tab[10];

Il est possible d'initialiser un tableau au moment de sa définition. Les membres non initialisés seront forcés à 0 :

/* Définition d'un tableau de 20 entiers
 * de type long avec initialisation a 0
 */
long tab[20] = {0};

/* Définition d'un tableau de 5 flottants
 * de type double avec initialisation partielle
 */
double tab[5] = {12.34, 56.78};

Enfin, il est possible de déterminer la taille d'un tableau par son initialisation. La taille s'ajuste alors en fonction du nombre d'initialiseurs :

/* Définition d'un tableau de 6 entiers
 * de type int initialises
 */
int tab[] = {1, 2, 3, 4, 5, 6};

Grâce à l'opérateur sizeof, il est possible de déterminer le nombre d'éléments d'un tableau. Il suffit de diviser la taille du tableau (en bytes) par la taille d'un élément du tableau (en bytes) (par exemple, [0], mais la valeur exacte de l'indice est sans importance).

/* Nombre d'éléments de 'tab' */
size_t nb_elem = sizeof tab / sizeof tab[0];

Le type est une des propriétés qui caractérise une valeur. Elle permet de préciser quelle est la gamme de valeurs possible. La norme qui définit le langage C précise qu'en fonction du type, ces valeurs doivent couvrir une gamme minimale.

Il y a quatre mots-clés du langage C qui définissent des types :

• char: petit entier, convient pour les caractères ;
• int: pour les valeurs numériques entières ;
• float: nombres à virgule flottante en simple précision ;
• double: nombres à virgule flottante en double précision.

On peut ajouter des mots-clés particuliers pour modifier la plage de valeurs (short, long) et / ou le fait que la valeur soit signée ou non (signed, unsigned), ce qui décale la plage de valeurs. L'ordre n'a pas d'importance, du moment que ces mots sont placés avant l'identificateur de type.

Voici les types entiers courants avec leurs gammes de valeurs minimales. Les termes entre [] sont facultatifs.

Et uniquement en C99 :

On peut mentionner aussi un type défini par l'implémentation, qui est size_t. C'est le type qui est retourné par l'opérateur sizeof. Ce type (entier non signé) est conçu pour contenir des informations du genre « taille d'un objet ». Par conséquent, il convient aussi aux indices (croissants) des tableaux ainsi qu'aux nombres d'éléments des tableaux.