Initiation au langage C

Les entrées/sorties (E/S) ne font pas vraiment partie du langage C car ces opérations sont dépendantes du système. Cela signifie que pour réaliser des opérations d'entrée/sortie en C, il faut en principe passer par les fonctionnalités offertes par le système. Néanmoins sa bibliothèque standard est fournie avec des fonctions permettant d'effectuer de telles opérations afin de faciliter l'écriture de code portable. Les fonctions et types de données liées aux entrées/sorties sont principalement déclarés dans le fichier stdio.h (standard input/output).

Les entrées/sorties en langage C se font par l'intermédiaire d'entités logiques, appelés flux, qui représentent des objets externes au programme, appelés fichiers. Un fichier peut être ouvert en lecture, auquel cas il est censé nous fournir des données (c'est-à-dire être lu) ou ouvert en écriture, auquel cas il est destiné à recevoir des données provenant du programme. Un fichier peut être à la fois ouvert en lecture et en écriture. Une fois qu'un fichier est ouvert, un flux lui est associé. Un flux d'entrée est un flux associé à un fichier ouvert en lecture et un flux de sortie un flux associé à un fichier ouvert un écriture. Tous les fichiers ouverts doivent être fermés avant la fin du programme.

Lorsque les données échangées entre le programme et le fichier sont de type texte, la nécessité de définir ce qu'on appelle une ligne est primordiale. En langage C, une ligne est une suite de caractères terminée par le caractère de fin de ligne (inclus) : '\n'. Par exemple, lorsqu'on effectue des saisies au clavier, une ligne correspond à une suite de caractères terminée par ENTREE. Puisque la touche ENTREE termine une ligne, le caractère généré par l'appui de cette touche est donc, en C standard, le caractère de fin de ligne soit '\n'.

Lorsque le système exécute un programme, trois fichiers sont automatiquement ouverts :

• l'entrée standard par défaut le clavier
• la sortie standard, par défaut l'écran (ou la console)
• et l'erreur standard, par défaut associé à l'écran (ou la console)
  
  

Respectivement associés aux flux stdin, stdout et stderr. Ils sont automatiquement fermés avant la fin du programme.

Chez la majorité des systèmes, dont Windows et UNIX, l'utilisateur peut rediriger les entrée et sortie standards vers un autre fichier à l'aide des symboles < et >. Par exemple, exécutez le programme qui affiche « Hello, world » à partir de l'interpréteur de commandes à l'aide de la commande suivante (nous supposons que nous sommes sous Windows et que le programme s'appelle hello.exe) :

hello > sortie.txt

et vous verrez que le message sera imprimé dans le fichier sortie.txt et non à l'écran. Si le fichier n'existe pas, il sera créé. S'il existe déjà, son ancien contenu sera effacé.

Un deuxième et dernier exemple : écrire un programme qui affiche Hello, world en écrivant explicitement sur stdout, autrement dit avec un printf beaucoup plus explicite. On utilisera alors la fonction fprintf qui permet d'écrire du texte sur un flux de sortie, dans notre cas : stdout, ce qui nous donne :

#include <stdio.h>
 
int main()
{
    fprintf(stdout, "Hello, world\n");
    return 0;
}

La macro getc permet de lire un caractère sur un flux d'entrée. La macro putc permet d'écrire un caractère sur un flux de sortie. Voici un programme simple qui montre comment utiliser les macros getc et putc :

#include <stdio.h>
 
int main()
{
    int c; /* le caractere */
 
    printf("Veuillez taper un caractere : ");
    c = getc(stdin);
 
    printf("Vous avez tape : ");
    putc(c, stdout);
 
    return 0;
}

Vous vous demandez certainement la raison pour laquelle on a utilisé int plutôt que char dans la déclaration de c. Et bien tout simplement parce que getc retourne un int (de même putc attend un argument de type int). Mais justement : Pourquoi ? Et bien parce que getc doit pouvoir non seulement retourner le caractère lu (un char) mais aussi une valeur qui ne doit pas être un char pour signaler qu'aucun caractère n'a pu être lu. Cette valeur est EOF. Elle est définie dans le fichier stdio.h. Dans ces conditions, il est clair qu'on peut utiliser tout sauf un char comme type de retour de getc.

Un des cas les plus fréquents où getc retourne EOF est lorsqu'on a rencontré la fin du fichier. La fin d'un fichier est un point situé au-delà du dernier caractère de ce fichier (si le fichier est vide, le début et la fin du fichier sont donc confondus). On dit qu'on a rencontré la fin d'un fichier après avoir encore tenté de lire dans ce fichier alors qu'on se trouve déjà à la fin, pas juste après avoir lu le dernier caractère. Lorsque stdin est associé au clavier, la notion de fin de fichier perd à priori son sens car l'utilisateur peut très bien taper n'importe quoi à n'importe quel moment. Cependant l'environnement d'exécution (le système d'exploitation) offre généralement un moyen de spécifier qu'on n'a plus aucun caractère à fournir (concrètement, pour nous, cela signifie que getc va retourner EOF). Sous Windows par exemple, il suffit de taper en début de ligne la combinaison de touches Ctrl + Z (héritée du DOS) puis de valider par ENTREE. Evidemment, tout recommence à zéro à la prochaine opération de lecture.

Les macros getchar et putchar s'utilisent comme getc et putc sauf qu'elles n'opèrent que sur stdin, respectivement stdout. Elles sont définies dans stdio.h comme suit :

#define getchar() getc(stdin)
#define putchar(c) putc(c, stdout)

Et enfin fgetc est une fonction qui fait la même chose que getc (qui peut être en fait une fonction ou une macro ...). De même fputc est une fonction qui fait la même chose que putc.

Il suffit de lire les caractères présents sur le flux d'entrée (dans notre cas : stdin) jusqu'à ce que l'on ait atteint la fin du fichier ou le caractère de fin de ligne. Nous devrons fournir en arguments de la fonction l'adresse du tampon destiné à contenir la chaîne de caractère saisie et la taille de ce tampon pour supprimer le risque de débordement de tampon.

#include <stdio.h>
 
char * saisir_chaine(char * lpBuffer, size_t nBufSize);
 
int main()
{
    char lpBuffer[20];
 
    printf("Entrez une chaine de caracteres : ");
    saisir_chaine(lpBuffer, sizeof(lpBuffer));
 
    printf("Vous avez tape : %s\n", lpBuffer);
 
    return 0;
}
 
char * saisir_chaine(char * lpBuffer, size_t nBufSize)
{
    size_t nbCar = 0;    
    int c;
 
    c = getchar();
    while (nbCar < nBufSize - 1 && c != EOF && c != '\n')
    {
        lpBuffer[nbCar] = (char)c;
        nbCar++;
        c = getchar();
    }
 
    lpBuffer[nbCar] = '\0';
 
    return lpBuffer;
}

La fonction scanf permet également de saisir une chaîne de caractères ne comportant aucun espace (espace, tabulation, etc.) grâce au spécificateur de format %s. Elle va donc arrêter la lecture à la rencontre d'un espace (mais avant d'effectuer la lecture, elle va d'abord avancer jusqu'au premier caractère qui n'est pas un espace). scanf ajoute enfin le caractère de fin de chaîne. Le gabarit permet d'indiquer le nombre maximum de caractères à lire (caractère de fin de chaîne non compris). Lorsqu'on utilise scanf avec le spécificateur %s (qui demande de lire une chaîne sans espace), il ne faut jamais oublier de spécifier également le nombre maximum de caractères à lire (à mettre juste devant le s) sinon le programme sera ouvert aux attaques par débordement de tampon. Voici un exemple qui montre l'utilisation de scanf avec le spécicateur de format %s :

#include <stdio.h>

int main()
{
    char lpBuffer[20];

    printf("Entrez une chaine de caracteres : ");
    scanf("%19s", lpBuffer);

    printf("Vous avez tape : %s\n", lpBuffer);

    return 0;
}

Et enfin, il existe également une fonction, gets, déclarée dans stdio.h, qui permet de lire une chaîne de caractères sur stdin. Cependant cette fonction est à proscrire car elle ne permet pas de spécifier la taille du tampon qui va recevoir la chaîne lue.

La fonction fgets permet de lire une ligne (c'est-à-dire y compris le '\n') sur un flux d'entrée et de placer les caractères lus dans un buffer. Cette fonction ajoute ensuite le caractère '\0'. Exemple :

#include <stdio.h>
 
int main()
{
    char lpBuffer[20];
 
    printf("Entrez une chaine de caracteres : ");
    fgets(lpBuffer, sizeof(lpBuffer), stdin);
 
    printf("Vous avez tape : %s", lpBuffer);
 
    return 0;
}

Dans cet exemple, deux cas peuvent se présenter :

• l'utilisateur entre une chaîne comportant 18 caractères tout au plus puis valide le tout par ENTREE, alors tous les caractères de la ligne, y compris le caractère de fin de ligne, sont copiés dans lpBuffer puis le caractère de fin de chaîne est ajouté
  
  
• l'utilisateur entre une chaîne comportant plus de 18 caractères (c'est-à-dire >= 19) puis valide le tout par ENTREE, alors seuls les 19 premiers caractères sont copiés vers lpBuffer puis le caractère de fin de chaîne est ajouté

V-G-1. Le tamponnage▲

int setvbuf(FILE * f, char * buf, int mode, size_t size);

#include <stdio.h>
 
#define N 1
 
void loop(unsigned long n);
 
int main()
{
    setvbuf(stdout, NULL, _IOFBF, 8);
 
    printf("a\n"); /* Contenu du buffer : [a\n]. */
    loop(N); /* Faire une quelconque longue boucle */
 
    /* Le buffer n'est pas encore plein, rien ne s'affichera donc sur la sortie standard. */
 
    printf("b\n"); /* Contenu du buffer : [a\nb\n]. */
    fflush(stdout); /* Vider le buffer. */
 
    /* Le buffer n'est pas encore plein mais fflush a ete appelee. On aura donc :   */
    /* - Sur la sortie standard : + [a\nb\n].                                       */
    /* - Dans le buffer : [] (rien).                                                */
 
    loop(N); /* Faire une quelconque longue boucle */
 
    printf("azertyuiop\n");
 
    /* On aura :                                          */
    /* - Dans le buffer : [azertyui].                     */
    /* Le buffer est plein, le vidage s'impose. On aura : */
    /* - Sur la sortie standard : + [azertui].            */
    /* - Dans le buffer : [] (rien).                      */
    /* Il reste encore les carateres [op\n]. On aura :    */
    /* - Dans le buffer : [op\n].                         */
 
    loop(N); /* Faire une quelconque longue boucle */
 
    return 0;
 
    /* Au dela de l'accolade : Fin du programme.                                           */
    /* Tous les fichiers encore ouverts (dont la sortie standard) seront fermes. On aura : */
    /* - Sur la sortie standard : + [op\n].                                                */
    /* - Dans le buffer : [] (rien).                                                       */
}
 
void loop(unsigned long n)
{
    unsigned long i, j, end = 100000000;
 
    for(i = 0; i < n; i++)
        for(j = 0; j < end; j++);
}

V-G-2. Lire de manière sûre des données sur l'entrée standard▲

#include <stdio.h>
 
int main()
{
    char nom[12], prenom[12];
 
    printf("Entrez votre nom : ");
    fgets(nom, sizeof(nom), stdin);
 
    printf("Entrez votre prenom : ");
    fgets(prenom, sizeof(prenom), stdin);
 
    printf("Votre nom est : %s", nom);
    printf("Et votre prenom : %s", prenom);
 
    return 0;
}

#include <stdio.h>
 
int main()
{
    int n;
    char c;
 
    printf("Entrez un nombre (entier) : ");
    scanf("%d", &n);
 
    printf("Entrez un caractere : ");
    scanf("%c", &c);
 
    printf("Le nombre que vous ave entre est : %d\n", n);
    printf("Le caractere que vous ave entre est : %c\n", c);
 
    return 0;
}

char * saisir_chaine(char * lpBuffer, int nBufSize)
{
    char * ret = fgets(lpBuffer, nBufSize, stdin);
 
    if (ret != NULL)
    {
        char * p = lpBuffer + strlen(lpBuffer) - 1;
        if (*p == '\n')
            *p = '\0'; /* on ecrase le '\n' */
        else
        {
            /* On vide le tampon de lecture du flux stdin */
            int c;
 
            do
				c = getchar();
            while (c != EOF && c != '\n');
        }
    }
 
    return ret;
}