Par O. Bailleux, Maître de conférences HDR à l'université de Bourgogne.

Chaînes de caractères en C

Les activités #.dec (dec pour Découverte) consistent à étudier des présentations explicatives et à traiter tous les exercices de découverte proposés. Si vous ne répondez pas correctement à un exercice de découverte, revenez en arrière pour relire les explications et identifier la cause de votre erreur.

Les activités #.ent (ent pour Entrainement) consistent à traiter des exercices d’entraînement. Vous devez d’abord tenter de traiter ces exercices sans dévoiler d’indice ni regarder la solution. Vous pouvez remonter dans le document pour relire certaines explications ou consulter les solutions des exercices de découverte ou d’entraînement précédemment traités.

Activité de découverte D.dec

D.dec1 : Représentation des chaînes

Prérequis

Partie C : Bien maîtriser les tableaux, les pointeurs et les fonction traitant des tableaux.

Objectif

Représenter et utiliser des chaînes de caractères dans un programme en langage C.

Les chaînes de caractères ont de nombreuses utilisations possibles. Elle permettent la prise en compte d’informations exprimées en langage naturel et d’une manière plus générale de données qui ne sont pas numériques ou ne sont pas initialement représentées par des types numériques. On a donc besoin de les représenter, de les stocker, de les afficher.

Moyen

Les chaînes sont représentées par des tableaux de caractères.

Il n’y a pas de type pour les chaînes de caractères en langage C, mais une convention de représentation : une chaîne est représentée par une suite de caractères terminée par un marqueur de fin de chaîne et stockée dans un tableau de caractères.

Pour bien comprendre de quoi on parle, il faut se rappeler qu’il existe un type char qui représente des entiers signés codées sur 8 bits et qui peut aussi être utilisé pour représenter des caractères. L’exécution des lignes suivantes…

char c = 'H';             // Ligne A
printf("%x %c\n",c, c);   // Ligne B
c = 35;                   // Ligne C
printf("%x %c\n",c, c);   // Ligne D

…produit l’affichage :

48 H
23 #

En ligne A, la variable c est initialisée avec le code ASCII du caractère 'H'.

En ligne B, la valeur de cette variable est affichée deux fois, dans deux formats différents : en hexadécimal et sous forme de caractère. 48 est la représentation hexadécimale du code ASCII de 'H'.

En ligne C, la même variable reçoit l’entier dont la représentation décimale est 35. Dans n’importe quel autre langage, à part peut-être l’assembleur, ce serait impensable de faire cela. Mais pour le compilateur C il n’y a aucun problème, puisque les caractères sont des entiers.

En ligne D, on affiche deux fois la valeur de la variable c, dans deux formats différents : en hexadécimal et sous forme de caractère. Le nombre entier noté 35 en décimal se note 23 en hexadécimal, et c’est par ailleurs le code ASCII du caractère '#'.

Exercice de découverte D.dec.x1

Sans utiliser de compilateur ni de table de codes ASCII, tentez de déterminer les valeurs affichées par l’exécution de ces lignes de code.

printf("%d ",'H' - 'A');
printf("%c\n", 'a' + 3);
Réponse

7 d

Les codes ASCII des lettres majuscules se suivent. Le code ASCII de 'H' est donc égal à celui de 'A' plus 7. La différence entre les deux vaut 7, et il n’est pas nécessaire de connaître les codes de 'A' et de 'H' pour le déduire.

D’autre part, les codes ASCII des lettres minuscules se suivent. Donc si on ajoute 3 au code ASCII de 'a', on obtient le code ASCII de 'd'.

Le deuxième point important à comprendre est le principe de représentation des chaînes. Examinons un exemple.

La fonction suivante permet d’afficher en hexadécimal les n premières valeurs du tableau de caractères désigné par tab.

void printHex(char tab[], int n)
{
    for(int i=0; i<n; i++)      
    {
        printf("%02x ", tab[i]);
    }
    printf("\n");
}

Si vous maîtrisez les prérequis (parties A, B et C), la compréhension de son fonctionnement ne doit pas vous poser de problème. Maintenant, on définit la fonction main suivante.

int main()
{
    char s[11] = "Tim et Tom";   // Ligne A
    printHex(s,11);              // Ligne B
    printf("%s\n", s);           // Ligne C 
    s[3] = 0;                    // Ligne D
    printf("%s\n", s);           // Ligne E 
    printHex(s,11);              // Ligne F
}

L’affichage obtenu est :

54 69 6d 20 65 74 20 54 6f 6d 00 
Tim et Tom
Tim
54 69 6d 00 65 74 20 54 6f 6d 00 

La ligne A crée un tableau de 11 caractères et l’initialise en y plaçant la chaîne "Tim et Tom".

La ligne B affiche le détail du contenu du tableau. On y voit les codes ASCII des caractères de la chaîne suivis de la valeur 0. ceci nous permet de comprendre deux choses :

  1. Le compilateur a traduit la notation entre double cotes de la ligne A en une suite de caractères qui ont été placés dans les cellules du tableau.
  2. La valeur 0, qui est affichée sous la forme 00 car la fonction printHex affiche toutes les valeurs avec deux chiffres pour des raisons purement esthétiques, fait office de marqueur de fin de chaîne. Attention, il s’agit bien de la valeur 0 et pas du caractère '0'.

La ligne C nous montre que printf peut afficher des chaînes si on le lui demande en utilisant le format d’affichage %s. Elle produit l’affichage "Tim et Tom". Le marqueur de fin de chaîne n’est pas affiché.

La ligne D place un marqueur de fin de chaîne juste après "Tim".

La ligne E affiche à nouveau la chaîne désignée par s, et cette fois-ci seul "Tim" est affiché.

La ligne F permet de voir la nouvelle représentation en mémoire. Les caractères représentant la fin de la chaîne initiale sont toujours là, mais il ne sont pas affichés car printf, avec le format %s, arrête l’affichage dès la première occurrence du marqueur de fin de chaîne et ignore tout ce qui suit.

Une conclusion s’impose : une chaîne peut être plus petite que le tableau qui la contient. Par contre ce serait une très mauvaise idée de placer dans un tableau une chaîne plus grande (en incluant le marqueur de fin) que la taille de ce tableau.

Exercice de découverte D.dec.x2

Sans utiliser de compilateur, donnez les affichages produits par ces lignes de code.

char s[] = {'0','0','0',0};
printf("%s\n", s);
s[0] = 0;
printf("%s\n", s);
Réponse

000

Le premier appel à printf affiche la chaîne constituée de trois caractères '0'. Ensuite, le marqueur de fin est placé en début du tableau, ce qui transforme la chaîne contenue dans ce tableau en chaîne vide. Donc le deuxième printf n’affiche rien.

Exercice de découverte D.dec.x3

À la compilation, une des lignes de codes suivantes produit une erreur. Laquelle, et pourquoi ?

char str[10] = "Tim";   // Ligne A
printf("%s\n", str);    // Ligne B
str = "Tom";            // Ligne C
printf("%s\n", str);    // Ligne D
Réponse

La ligne C est incorrecte car on ne peut pas utiliser = pour assigner un tableau, mais seulement pour assigner une de ces cellules. L’utilisation de = en ligne A est autorisée car il s’agit d’une initialisation qui est réalisée au moment de la création du tableau.

Exercice de découverte D.dec.x4

Quel affichage est produit par l’exécution des lignes de code suivantes et pourquoi ?

char s1[] = "Tim";
char s2[] = "Tim";
if(s1 == s2) printf("Yes\n");
else printf("No\n");
Réponse

L’affichage est No car pour le compilateur, s1 et s2 sont les adresses mémoire des tableaux contenant les deux chaînes. C’est une conséquence directe de la correspondance entre pointeurs et tableaux qui a été expliquée dans la partie précédente. La notation s1 == s2 compare les adresses mémoire de deux tableaux différents ayant le même contenu. Le résultat est la valeur Booléenne false (représentée, pour mémoire, par l’entier 0).

Récapitulons
  • Une chaîne est représentée par des suites de caractères situées dans un tableau et terminées par un marqueur de fin de chaîne qui est l’entier 0 (au format char, c’est à dire codé sur 8 bits).
  • Une chaîne peut être plus petite que le tableau qui la contient. Les caractères situés après le marqueur de fin ne sont pas significatifs.
  • Une chaîne peut être représentée, dans un code source, entre double cotes, comme par exemple "Tim". On parle de chaîne littérale.
  • Un tableau de caractères peut être initialisé avec une chaîne de caractères en utilisant = et la notation entre double cotes.
  • Le format %s permet à printf d’afficher des chaînes de caractères.

Bonus

Quelques subtilités
Caractères d’échappement

Le marqueur de fin de chaîne, c’est à dire l’entier 0, n’est pas un caractère imprimable. Il peut être aussi représenté avec la notation '\0'. Il existe d’autres caractères spéciaux tels que '\n', indiquant un retour à la ligne, que nous avons déjà souvent utilisé, '\t' qui représente la tabulation, et '\a' qui émet un beep sonore !

Zones de stockage des chaînes

Examinons les lignes de code suivantes.

    char s1[] = "Tim";     // Ligne A
    char* s2 = "Tom";      // Ligne B
    printf("%s et %s\n", s1, s2);

Leur exécution a pour effet l’affichage Tim et Tom. Il semble donc y avoir deux manières d’initialiser un tableau avec une chaîne de caractères. Mais si ensuite on écrit…

    s1[0] = 'X';           // Ligne C
    s2[0] = 'X';           // Ligne D
    printf("%s et %s\n", s1, s2);

…il peut se produire des choses fâcheuses, tel que par exemple un arrêt du programme avant la fin de son exécution. Voici l’explication.

En ligne A, on crée un tableau de caractères situé dans la pile et on l’initialise avec une chaîne. Ce tableau est modifiable, c’est à dire que son contenu peut changer au cours de l’exécution de la fonction à laquelle il appartient.

En ligne B, on crée un tableau de caractères situé dans une zone mémoire dédiées au stockage de données non modifiables. Ce tableau ne peut pas être modifié. La chaîne qu’il contient est une constante.

En ligne D, on tente de modifier le premier caractère de la chaîne constante. Cela peut fonctionner sur certains systèmes anciens, rudimentaires ou permissifs, mais avec les systèmes modernes, cela provoque une erreur d’exécution.

D’ailleurs, la bonne manière d’écrire la ligne B est la suivante :

    const char* s2 = "Tom";

Ainsi, la tentative de modification de la ligne D provoque une erreur à la compilation et non lors de l’exécution.

Attention à la taille du tableau de stockage

Pour dimensionner une tableau destiné à contenir une chaîne, il faut toujours penser au marqueur de fin. Par exemple dans les lignes de code suivantes…

    char s[3] = "Tim";
    printf("%s\n", s);

…Il y a une erreur. Le tableau désigné par s comporte trois cellules, mais il en faut 4 pour stocker la chaîne "Tim" et son marqueur de fin. Le compilateur que j’ai utilisé n’y a vu que du feu, et le programme fonctionne, mais à l’exécution, la valeur 0 est écrite au delà de la fin du tableau. Cette erreur peut passer complètement inaperçue à l’exécution, mais peut occasionnellement provoquer un dysfonctionnement grave du programme. Un programme en langage C ne doit en aucun cas comporter ce genre d’erreur.

Si on écrit…

    char s[] = "Tim";

…le compilateur crée un tableau de 4 caractères et l’initialise correctement.

D.dec2 : Fonctions standards relatives aux chaînes

Prérequis

Bien maîtriser la partie précédente.

Objectif

Faciliter des opérations utilisées fréquemment avec des chaînes, telles que la comparaison, la copie, la concaténation…

Nous avons vu que l’opérateur d’assignation = ne permet pas de copier une chaîne dans un tableau de caractère existant (il permet juste d’initialiser un tableau lors de sa déclaration). Nous avons également vu que l’opérateur == ne permet pas de comparer les contenus de deux chaînes, mais seulement leurs adresses mémoire. Nous savons aussi que disposer de l’adresse d’un tableau ne nous permet pas de connaitre sa taille, et que de toutes façons, une chaîne peut être plus courte que le tableau qui la contient. Pour connaitre la longueur d’une chaîne, il faut donc compter les caractères situés avant la marqueur de fin. Pour simplifier ces opérations et d’autres particulièrement utiles, il existe des fonctions standards dédiées au traitement des chaînes. Elle sont déclarées dans le fichier d’entête string.h.

Moyen

Quelques fonctions standards très utiles

Seules les fonctions les plus couramment utilisées sont présentées ici. Vous pourrez en trouver d’autres en consultant des sources documentaires telles que Koor.fr ou encore le wiki livre sur la programmation C.

Longueur d’une chaîne
    size_t strlen( const char * theString );

Retourne la longueur de la chaîne désignée par le paramètre theString. La valeur de retour est un entier long non signé (type size_t), mais sauf si vous utilisez des chaînes de plus de 2 milliards de caractères, le résultat peut être « casté » en int.

    char s[] = "Tim";
    int longueur = (int)strlen(s);
    printf("%d\n", longueur);
Copie d’une chaîne
char * strcpy( char * destination, const char * source );
char * strncpy( char * destination, const char * source, size_t length );

La première version copie la chaîne désigné par source dans le tableau désigné par destination. Il faut impérativement que le tableau de destination ait une taille suffisante pour contenir la chaîne copiée en incluant (comme toujours !) son marqueur de fin. Aucune vérification n’est faite par la fonction. La valeur de retour est l’adresse du tableau de destination. C’est une information redondante (puisque cette adresse est donnée en paramètre) qu’il vaut mieux ignorer. Le marqueur de fin est copié.

La deuxième version a un paramètre supplémentaire qui limite le nombre de caractères à copier. Dans le cas où la chaîne source est trop grande pour être complètement copiée, le marqueur de fin n’est pas ajouté à la chaîne de destination.

Exercice de découverte D.dec.x5

Quels sont les affichages réalisés par l’exécution des lignes de code suivantes ?

    char s[10] = "aaaaa";
    strcpy(s+3, "bbbbb");
    printf("%s\n", s);
Réponse

aaabbbbb

L’adresse de destination de la copie, s+3, est celle de la quatrième cellule du tableau désigné par s. (Pour mémoire, s ou s+0 est l’adresse de la première cellule.) Ceci est une conséquence de l’arithmétique des pointeurs et de la correspondance entre tableaux et pointeurs, qui sont des notions fondamentales. La copie de la chaîne source ne recouvre donc que partiellement la chaîne de destination initiale.

Concaténation
char * strcat( char * destination, const char * source );
char * strncat( char * destination, const char * source, size_t size  );

La première version ajoute la chaîne désigné par source à la fin de la chaîne située dans le tableau désigné par destination. Il faut impérativement que le tableau de destination ait une taille suffisante pour contenir le résultat en incluant (comme toujours !) son marqueur de fin. Aucune vérification n’est faite par la fonction. La valeur de retour est l’adresse du tableau de destination. C’est une information redondante (puisque cette adresse est donnée en paramètre) qu’il vaut mieux ignorer. Un marqueur de fin est ajouté à la chaîne de destination.

La deuxième version a un paramètre supplémentaire qui limite le nombre de caractères à copier. Dans le cas où la chaîne source est trop grande pour être complètement copiée, le marqueur de fin n’est pas ajouté à la chaîne de destination.

Exercice de découverte D.dec.x6

Soit la ligne de code suivante.

    char s[10] = "abc";

Quelle ligne faut-il ajouter pour concaténer la chaîne "def" à celle déjà présente dans le tableau désigné par s ?

Réponse

    strcat(s, "def");

Exercice de découverte D.dec.x7

Examinez les lignes de code suivantes.

    char s[10] = "abcde";
    strcat(s, "fghij");
    printf("%s\n", s);

Y-a-t’il une erreur ? Et si oui laquelle ?

Réponse

Il y a une erreur. La concaténation des deux chaînes occupe 11 caractères en comptant le marqueur de fin. Il n’y a pas assez de place dans le tableau de destination.

Comparaison
int strcmp( const char * first, const char * second );

Cette fonction compare les chaines désignées par les deux paramètres sur la base de l’ordre lexicographique des codes ASCII. Dans cet ordre, les chiffres sont situés avant les lettre majuscules, qui sont situées avant les lettres minuscules. La valeur de retour est négative si la première chaîne est située avant la deuxième dans l’ordre lexicographique, elle vaut 0 si les deux chaînes sont identiques, sinon elle est positive.

Exercice de découverte D.dec.x8

Indiquez, pour chacune des lignes de code suivantes, si elle affiche une valeur négative, positive ou nulle.

    printf("%d\n", strcmp("abc", "Abc"));
    printf("%d\n", strcmp("ab", "abc"));
    printf("%d\n", strcmp("ab", "a123"));
Réponse

1 -1 1

D.dec3 : Conception de fonctions traitant des chaînes

Prérequis

Maîtriser les pointeurs et tableaux et avoir bien compris les notions introduites dans les sections précédentes.

Objectif

Réaliser des fonctions acceptant des chaînes en paramètres et capable de réaliser des traitements sur ces chaînes

Les fonctions standards répondent à des besoins courants, mais il arrive souvent qu’un développeur doivent réaliser des traitements spécifiques pour lesquels il est souhaitable de définir des fonctions pouvant être utilisées autant de fois que nécessaire sans duplication de code.

Moyen

Paramètres de type pointeurs sur des tableaux

Les techniques vues dans la partie C à propos du passage de tableaux en paramètres (plus exactement de pointeurs désignant des tableaux) sont directement applicables aux fonctions devant réaliser des traitements sur des chaînes de caractères. C’est même plus simple car contrairement aux tableaux d’usage général dont on ne peut retrouver la taille à partir de leurs adresses, on peut connaitre la longueur d’une chaîne de caractères à l’aide de la fonction strlen vue précédemment.

Examinons un exemple pas à pas. Nous nous fixons pour objectif de réaliser une fonction filtre qui produit une chaîne de sortie obtenue en retirant d’une chaîne d’entrée les caractères autres que les chiffres et les lettres (minuscules et majuscules).

Transmettre la chaîne d’entrée à la fonction

Il est naturel de passer en paramètre la chaîne d’entrée, sous la forme d’un pointeur. C’est la manière habituelle de procéder avec les fonctions agissant sur des tableaux, or les chaînes sont des tableaux de caractères.

Récupérer la chaîne de sortie

Il pourrait sembler naturel de faire en sorte que la fonction à réaliser retourne la chaîne de sortie. Mais c’est une mauvaise idée car une fonction ne peut retourner que l’adresse d’un tableau et non son contenu. C’est une limitation du langage C. De plus une fonction ne doit en aucun cas retourner l’adresse d’une des ses variables locales, car la dite variable n’existe plus à l’issue de l’exécution de la fonction.

La solution consiste à transmettre deux tableaux en paramètre : un contenant la chaîne d’entrée et l’autre destiné à récupérer la chaîne de sortie. La personne écrivant du code qui appelle la fonction devra impérativement faire en sorte que la taille du tableau de sortie soit suffisante pour recevoir le résultat.

Voici un exemple avec une fonction recopie qui se contente de donner la chaîne d’entrée non modifiée comme résultat et une fonction main qui montre comment appeler la fonction recopie.

void recopie(const char* entree, char* sortie)
{
    strcpy(sortie, entree);
}

int main()
{
    char donnee[] ="abcdef";
    char resultat[strlen(donnee)+1];
    recopie(donnee, resultat);
    printf("%s %s\n", donnee, resultat);
    return 0;
}

Avant l’appel de la fonction recopie, on crée un tableau de taille suffisante pour récupérer le résultat.

Exercice de découverte D.dec.x9

Pourquoi la taille du tableau resultat est-elle fixée à strlen(donnee+1) et pas à strlen(donnee) ?

Réponse

Parce-que strlen(donnee) retourne le nombre de caractères de la chaîne donnee sanst comptabiliser le marqueur de fin. Or il faut prévoir la place pour ce marqueur dans le chaine resultat.

Voici un dessin qui montre la configuration en mémoire juste avant la fin de l’exécution de la fonction recopie.

image-20211230104143581

Il faut bien comprendre que les tableaux d’entrée et de sortie n’existent qu’en un seul exemplaires dans (l’espace mémoire de) main et que ce sont seulement leurs adresses qui sont transmises à recopie. Ceci n’a rien de nouveau, c’est la manière usuelle de procéder avec des fonctions agissant sur des tableau, comme nous l’avons vu dans la partie C.

Réaliser le traitement

Notre objectif est de définir une fonction filtre qui supprime de la chaîne tout autre caractère que les lettres et chiffres. Mais comment savoir si un caractère est une lettre, un chiffre ou autre chose ? Il existe des fonctions standards pour ça, mais c’est tellement simple et instructif à programmer que nous allons définir notre propre fonction.

int alphaNum(char c)
{
    if((c>='a') && (c<='z')) return 1;
    if((c>='A') && (c<='Z')) return 1;
    if((c>='0') && (c<='9')) return 1;
    return 0;
}

On aurait pu utiliser une seule grosse condition avec des || et des &&, mais au détriment de la lisibilité.

Voici maintenant la définition de la fonction qui est notre objectif depuis le début de cette section.

void filtre(const char* entree, char* sortie)
{
    int curseurSortie = 0;
    int n = strlen(entree);
    for(int i=0; i<n; i++)
    {
        if(alphaNum(entree[i]))
        {
            sortie[curseurSortie] = entree[i];
            curseurSortie++;
        }
    }
    // Ne manquerait-il pas quelque chose ?
}

Ici, nous sommes face à un problème d’algorithmique. Pour le résoudre, j’ai utilisé une boucle for qui parcours un à un tous les caractères de la chaîne d’entrée. Une variable appelée curseurSortie, initialisée à 0, indique la position où le prochain caractère éligible sera ajouté, si applicable, à la chaîne de sortie. Cette variable est incrémentée après chaque ajout de caractère à la chaîne de sortie.

Exercice de découverte D.dec.10

Mais il manque quelque-chose pour garantir le bon fonctionnement de cette fonction. De quoi s’agit-il et pourquoi ?

Réponse

À la place du commentaire à la fin de la définition de la fonction filtre, il faut ajouter..

    sortie[curseurSortie] = 0;

…pour être sûr que la chaîne de sortie se termine bien par le marqueur de fin. en effet, le marqueur de fin de la chaîne d’entrée n’est pas recopié par la boucle.

Vous avez maintenant toutes les clés pour réaliser vos propres fonctions de traitement de chaînes de caractères. Des exercices d’entraînement vous permettrons de monter en compétence dans ce domaine. Mais auparavant, nous allons voir comment exploiter les arguments de la ligne de commande.

D.dec4 : Exploitation des arguments de la ligne de commande

Prérequis

Avoir bien compris les notions et techniques présentée dans les sections D.dec1 et D.dec2

Objectif

Réaliser un programme exploitant des arguments passés en ligne de commande

Jusqu’à maintenant, nos programmes ne prenaient pas en compte des données fournies au clavier par la personne utilisatrice. L’un des moyens de prendre en compte de telles données est de demander à la personne utilisatrice de les saisir au moment de l’appel du programme. Prenons l’exemple d’un programme permettant de calculer rapidement la moyenne de quelques nombres.

Depuis la console, il s’utilise en tapant la nom du programme, moyenne, suivi des valeurs dont on veut la moyenne, séparées par des espaces. Voici un exemple :

> moyenne 12.5 10.0 8.5

Le programme doit alors afficher le résultat dans la console :

> 10.33

Pour permettre cela, notre programme doit récupérer les arguments de la ligne de commande, c’est à dire les données qui suivent le nom du programme exécutable et sont séparées par des espaces.

Moyen

Exploiter les paramètres de la fonction main

Jusqu’à maintenant, dans tous nos exemples, la fonction main n’avait pas de paramètres. Mais on peut utiliser une variante de main avec paramètres, comme dans l’exemple ci-dessous.

int main(int argc, char *argv[])
{
    printf("Arguments de la ligne de commande :\n");
    for(int i=0; i<argc; i++)
    {
        printf("%s\n", argv[i]);
    }
    return 0;
}

On compile le programme en donnant le nom progtest à l’exécutable et on le lance avec la ligne de commande suivante :

> progTest 12.5 10.0 8.5

L’affichage produit est :

./progtest
12.5
10.0
8.5

Voici les clés pour expliquer ce résultat.

  1. La valeur de argc est égale au nombre d’arguments passés en ligne de commande plus 1. Dans l’exemple d’appel ci-dessus, il vaut 4.
  2. argv désigne un tableau de pointeurs de type char* désignant des chaînes de caractères. argv[0] désigne une chaîne contenant le nom du programme, argv[1] désigne une chaîne de caractère contenant le premier argument passé en ligne de commande, argv[2] le deuxième argument, etc.

C’est donc sous la forme de chaînes de caractères que nous récupérons les arguments de la ligne de commande, même si ceux-ci ont l’apparence de nombres.

Pour notre application de calcul de moyenne, il va nous falloir transformer en valeurs de type double des données qui se présentent sous la forme de chaînes de caractères. Heureusement, il existe des fonctions toutes faites pour faire cela. Examinons le code du programme proposé. Attention, il faut inclure les fichiers d’entête string.h, stdlib.h et stdio.h pour le compiler.

int main(int argc, char *argv[])                // Ligne A
{
    double sum = 0.0;
    for(int i=1; i<argc; i++)
    {
        double valeur = 0.0;                    // Ligne B
        sscanf(argv[i], "%lf", &valeur);        // Ligne C
        sum = sum + valeur;
    }
    printf("Moyenne : %.02lf", sum / (argc-1));  // Ligne D
    return 0;
}

En ligne A, on définit la méthode main dans sa version permettant de récupérer les arguments de la ligne de commande.

En ligne B, on déclare une variable destinée à recevoir la valeur de type double représentée par un des arguments de la ligne de commande.

En ligne C, on utilise la très puissante fonction standard sscanf pour convertir en double la chaîne de caractères argv[i], c’est à dire l’argument apparaissant en position i dans la ligne de commande. Cette fonction lit une donnée dans une chaîne de caractères et la convertit, si applicable, dans le format indiqué en deuxième paramètre, ici "%lf" pour le format double. Le résultat est placé dans la variable dont l’adresse est donnée par le troisième paramètre de scanf.

En ligne D, la somme des valeurs passées via les arguments de la ligne de commande est divisée par le nombre d’arguments pour obtenir la moyenne, qui est affichée au format %.02lf, c’est à dire avec 2 chiffres après le point décimal.

Exercice de découverte D.dec.x11

Modifiez la fonction main de l’exemple pour qu’elle ne réalise aucun calcul et affiche le message « aucun argument » si aucun argument n’est passé à la ligne de commande.

Réponse

int main(int argc, char *argv[])
{
    if(argc==1)
    {
        printf("Aucun argument\n");
    }
    else
    {
        double sum = 0.0;
        for(int i=1; i<argc; i++)
        {
            double valeur;
            sscanf(argv[i], "%lf", &valeur);
            sum = sum + valeur;
        }
        printf("Moyenne : %.02lf", sum / (argc-1));
    }
    return 0;
}

Bonus

Saisie au clavier, compléments sur les flottants.
Les types flottants

Un petit hors sujet dans cette partie sur les chaînes. Jusqu’à maintenant nous avons toujours utilisé le type double pour représenter des nombres flottants. Mais il existe deux autres types nommés float et long double. Le premier occupe deux fois moins de mémoire que double, mais couvre une plage de valeurs plus faible et offre une précision moindre (6 décimales au lieu de 15). Le type long double offre une plus grande précision que double et occupe plus de place en mémoire. L’étude des ces types ne fait pas partie des objectifs du présent enseignement. Ils sont mentionnés ici pour information. Dans la suite, comme nous l’avons fait jusqu’ici, nous utiliserons uniquement le type double.

Dans les chaînes de formatage des fonctions printf et sscanf, le format %f signifie float alors que %lf signifie double. Mais printf ne fait pas de différence entre %f et %lf et convertit en double toute valeur de type float qui lui est passée en argument. En revanche, sscanf fait la distinction.

Les fonctions scanf et sscanf

Nous avons utilisé plus haut la fonction sscanf. Il existe une fonction similaire nommée scanf qui lit des données au clavier. Ces fonctions peuvent lire plusieurs valeurs en un seul appel, mais nous allons seulement voir leur utilisation pour lire une valeur.

La fonction…

int scanf( const char *format, void* destination );

… lit une valeur saisie au clavier. Le format de cette valeur est donné par le paramètre format. Pour lire un entier décimal on utilise le format "%d", pour lire un entier représenté en hexadécimal on utilise le format "%x", pour lire une valeur de type double, le format %lf, etc. Le résultat de la lecture est placé dans la variable pointée par destination.

La valeur de retour est 1 si une valeur est lue, 0 sinon.

Voici un exemple d’utilisation.

int main(int argc, char *argv[])
{
    int valeur = 0;
    scanf("%d", &valeur);
    printf("Valeur lue : %d\n", valeur);
}

À l’exécution si on saisit 102 et entrée, le programme affiche :

Valeur de retour : 1, Valeur lue : 102

Si on saisit 17abc et entrée, le programme affiche :

Valeur de retour : 1, Valeur lue : 17

Les caractères saisis sont convertis tant qu’ils sont en cohérence avec le type de valeur à saisir.

Si on saisit abc54 puis entrée, le programme affiche :

Valeur de retour : 0, Valeur lue : 0

La valeur de retour étant 0, aucune valeur n’est écrite dans la variable valeur, qui conserve sa valeur d’initialisation.

Le format de saisie %s est autorisé mais fortement déconseillée car on ne peut pas empêcher un débordement du tableau de destination et la saisie s’arrête non seulement si la touche entrée est tapée, mais aussi si la touche espace est tapée. Pour saisir une chaîne au clavier, il est conseillé d’utiliser la fonction standard fgets.

La fonction…

int sscanf( const char * buffer, const char *format, void* destination );

…se comporte comme scanf saut qu’au lieu de lire la donnée à saisir au clavier, elle la lit dans la chaîne de caractère désignée par buffer.

La fonction fgets
char * fgets( char * dest, int maxLength, FILE * stream );

Elle permet de lire une chaîne de caractères dans un fichier, ce qui est hors du scope de cet enseignement, mais peut être utilisée pour saisir une chaîne au clavier si la constante prédéfinie stdin est utilisée comme troisième argument. Le paramètre dest désigne le tableau dans lequel la chaîne saisie doit être placée. Le nombre maximum de caractères saisi est égal à maxLenght-1. Il est impératif qu’à l’appel, la valeur de MaxLength soit inférieure ou égale à la taille du tableau de destination désigné par dest. Voici un exemple d’utilisation.

int main(int argc, char *argv[])
{
    char buffer[10];
    fgets(buffer, 10, stdin);
    printf("Chaine saisie : %s", buffer);
}

Si on saisi la chaîne…

Bonjour, comment allez-vous ?

… Le programme affiche :

Chaine saisie : Bonjour, 

La saisie a été tronquée à 9 caractères. Le marqueur de fin est ajouté automatiquement.


L’activité est terminée. Vous devez évaluer votre réussite de cette activité par une valeur entre 1 et 4.

  1. Vous n’avez presque rien compris et échoué à plus de la moitié des exercices de découverte.
  2. Vous estimez avoir compris une partie des explications et vous avez réussi au moins la moitié des exercices de découverte, mais certaines notions sont encore floues.
  3. Vous estimez avoir bien compris les explications et vous avez réussi presque tous les exercices de découverte, mais certaines notions abordées étaient nouvelles et vous penser avoir besoin d’un entrainement pour bien les assimiler et être en mesure de les utiliser en pratique.
  4. Vous connaissiez déjà tout ce qui a été présenté (sauf peut être quelques détails) et il ne sera pas nécessaire que vous reveniez sur ces notions.

Si votre score est 1 ou 2, vous devrez refaire cette activité rapidement, mais après au moins une nuit de sommeil, avant de passer aux activités suivantes. Si votre score est 3 ou 4, vous devez faire les activités suivantes et il ne sera pas nécessaire de revenir sur cette activité, à part pour rechercher des informations utiles pour d’autres activités.


Activité d’entraînement D.ent

Cette activité est essentielle. C’est grâce à elle que vous apprendrez vraiment à comprendre et utiliser les notions vues précédemment. Elle se décompose en plusieurs itérations : ent1, ent2, etc.

Vous devez réaliser au moins une itération et évaluer votre niveau de réussite par une valeur entre 1 et 4 selon les critères habituels. L’itération que vous avez traité le plus récemment est appelée itération courante. On appelle itération suivante celle qui suit l’itération courante, excepté si l’itération courante est la dernière disponible, auquel cas l’itération suivante est la première itération.

Si le résultat est 1, vous devrez traiter à nouveau l’activité de découverte précédente, en laissant passer au moins une nuit, avant de revenir à cette activité d’entraînement en réalisant à nouveau l’itération courante. Vous devez aussi essayer d’identifier les points de blocage et demander à votre enseignant de vous aider à les surmonter.

Si le résultat est 2, vous devrez d’abord comprendre ce qui vous a conduit à des erreurs et / ou ce qui vous a bloqué. Si vous avez des doutes, des difficultés, essayez de trouver les réponses dans les présentations et explication de l’activité de découverte précédente et demandez toute l’aide nécessaire à votre enseignant. Ensuite, vous devrez réaliser l’itération suivante de l’activité d’entraînement actuelle après un délai d’au moins deux jours et d’au plus une semaine.

Si le résultat est 3, vous devrez revenir traiter l’itération suivante après un délai de plusieurs semaines.

En traitant les exercices, vous devrez considérer que les paramètres des fonctions ont des valeurs correctes. Il ne vous est pas demandé de vérifier si certaines valeurs sont aberrantes au regard de ce que demande l’énoncé. Par exemple, si un paramètre doit être positif pour que le traitement demandé soit possible, vous considérerez que la fonction sera appelée avec une valeur positive de ce paramètre.

Vous pouvez utiliser un ordinateur pour tester vos solutions et les corriger en cas de comportement inattendu. C’est même recommandé, à condition de commencer par réfléchir avant de vous jeter sur le clavier. Si vous pensez avoir une solution différente de celle proposée, ce qui peut arriver souvent, vous ne devez en aucun cas rester dans le doute. Vous devez vérifier si votre solution est correcte ou non, soit en testant votre solution avec un ordinateur, soit en demandant à une personne enseignante.

Itération D.ent1

Exercice d’entrainement D.ent1.1

Question 1. Sans utiliser de compilateur, donnez les affichages réalisés par l’exécution des lignes de code suivantes.

    char s1[20] = "aaaaaa";
    strcat(s1+2,"bbb");
    printf("%s\n", s1);          
Indice

Il faut dessiner les tableaux contenant les chaînes pour bien comprendre les effets des opérations réalisées.

image-20211231193411413

La chaîne "bbb" sera ajoutée à la fin de la chaîne commençant en s1+2. En effet, strcat réalise une concaténation et pas une simple copie.

Réponse

aaaaaabbb

Question 2. Même question avec les lignes suivantes.

    char s2[20] = "aaaaaa";
    strcpy(s2+2, "bbbbbb");
    printf("%s\n", s2);  
Indice

La fonction strcpy va écraser la partie de la chaîne initiale commençant à l’adresse s+2.

Réponse

aabbbbbb

Question 3. Même question avec les lignes suivantes.

    char s3[20] = "abcdef";
    s3[3] = 0;
    printf("%s %s\n", s3, s3+5); 
Indice

Dans une telle situation, il est extrêmement conseillé de faire un dessin.

image-20211231200852446

Réponse

abc f

Il faut comprendre que la chaîne désignée par s3+5 est juste constituée du caractère 'f'.

Question 4. Même question avec les lignes suivantes.

    char s4[20] = "abcdef";
    int n1 = strlen(s4);
    int n2 = strlen(s4+1);
    s4[n1] = '9';
    s4[n2] = 0;
    printf("%s\n", s4);
Indice

Ici encore, il faut faire un dessin des modifications réalisées par les deux lignes précédent l’appel à printf après avoir déterminé que n1 vaut 6 et que n2, c’est à dire la longueur de la chaîne "bcdef", vaut 5.

image-20211231192446243

Réponse

abcde

Le caractère '9' se retrouve au delà du marqueur de fin de chaîne et n’est donc pas affiché.

Exercice d’entrainement D.ent1.2

Vous devez implémenter une fonction…

void toutMaj(char* str)

…qui remplace toutes les lettre minuscules de la chaîne désignée par str par les lettre majuscules correspondantes. Toutes les occurrences de 'a' sont remplacées par 'A', les occurrences de 'b' sont remplacées par 'B', etc. Les autres caractères ne sont pas affectés.

Pour vérifier que vous avez parfaitement compris ce qui est demandé, donnez le code d’une fonction main qui place dans un tableau la chaîne "abc 12 Def" et appelle la fonction toutMaj pour transformer cette chaîne en "ABC 12 DEF" et afficher cette chaîne.

Réponse

int main()
{
    char s[] = "abc 12 Def";
	  toutMaj(s);
    printf("%s\n", s);
    return 0;
}

À présent vous pouvez réaliser la fonction toutMaj. Vous ne devez pas utiliser ni consulter de table de code ASCII. Vous n’en avez pas besoin car le langage C connait déjà ces codes. Si, par exemple, vous avez besoin du code ASCII de la lettre A, il suffit d’écrire 'A' et le compilateur considérera que cette notation est le code ASCII de A.

Indice

Il faut parcourir la chaîne initiale, identifier les lettres minuscules et les remplacer par les majuscules correspondantes. Pour déterminer si un caractère représente une lettre minuscule, il suffi de vérifier s’il est supérieur ou égal à 'a' et inférieur ou égal à 'z'. On peut comparer les caractères comme des entiers puisque ce sont des entiers.

Pour obtenir la lettre majuscule correspondant à une lettre minuscule située dans une variable c, il faut ajouter à c une valeur, que nous pouvons appeler delta, représentant la distance, dans le code ASCII, entre les lettres majuscules et les lettres minuscules. Essayez de trouver un moyen simple de calculer cette valeur delta.

void toutMaj(char* str)
{
    int n = strlen(str);
    int delta = // À compléter
    for(int i=0; i<n; i++)
    {
        // À compléter
    }
}

Indice2

Par définition, 'a' + delta vaut 'A' puisque delta est la valeur à ajouter à toute lettre minuscule pour obtenir la lettre majuscule correspondante. Donc delta vaut 'A' - 'a'. Évidemment, cette valeur est aussi égale à 'B' - 'b', 'C' - 'c', etc.

Solution

void toutMaj(char* str)
{
    int n = strlen(str);
    int delta = 'A' - 'a';
    for(int i=0; i<n; i++)
    {
        if((str[i]>='a') && (str[i]<='z'))
        {
            str[i] = str[i] + delta;
        }
    }
}

Exercice d’entrainement D.ent1.3

Vous devez implémenter une fonction…

void randomStr(const char* cars, char* dest, int n)

…qui produit une chaîne aléatoire constituée de n caractères tirés au hasard parmi les caractères situés dans la chaîne désignée par cars. Le résultat est placé dans le tableau désigné par dest, qui est supposé avoir une taille au moins égale à n+1.

Pour vérifier que vous avez parfaitement compris ce qui vous est demandé, donnez le code d’une fonction main qui utilise la fonction randStr pour produire et afficher une chaîne aléatoire constituée uniquement de 6 lettres majuscules.

Réponse

int main()
{
    srand(time(NULL));
    char cars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    char dest[7];
    randomStr(cars, dest, 6);
    printf("%s\n", dest);
    return 0;
}

Le tableau de destination a une taille égale à 7 pour recevoir les 6 caractères de la chaîne à produire plus le marqueur de fin.

Indice

void randomStr(const char* cars, char* dest, int n)
{
    int nCars = strlen(cars);
    for(int i=0; i<n; i++)
    {
        // À compléter
    }
    // À compléter
}

La production d’une caractère aléatoire peut se faire en lisant une valeur du tableau désigné par cars à un indice tiré aléatoirement entre 0 et nCars-1.

Solution

void randomStr(const char* cars, char* dest, int n)
{
    int nCars = strlen(cars);
    for(int i=0; i<n; i++)
    {
        dest[i] = cars[rand()%nCars];
    }
    dest[n] = 0;
}

Itération D.ent2

Exercice d’entrainement D.ent2.1

Question 1. Sans utiliser de compilateur, donnez les affichages réalisés par l’exécution des lignes de code suivantes.

    char s1[20] = "aaaaaa";
    strcpy(s1+3,"bbb");
    printf("%s\n", s1);          
Indice

Faites un dessin pour bien localiser l’emplacement à partir duquel la chaîne "bbb" et son marqueur de fin sont recopiés par l’appel de strcpy.

Réponse

aaabbb

Question 2. Même question avec les lignes suivantes.

    char s2[20] = "aaaaaa";
    strcpy(s2+strlen(s2), "bbb");
    printf("%s\n", s2);  
Indice

La fonction strcpy va copier la chaîne "bbb" juste après le dernier caractère de la chaîne "aaaaaa".

Réponse

aaaaaabbb

Question 3. Même question avec les lignes suivantes.

    char s3[20] = "abcdef";
    char r3[20];
    strcpy(r3,s3+3);
    printf("%s\n", r3);
Indice

La partie de la chaîne située dans le tableau désigné par s3 commençant en position 3 (donc à partir du quatrième caractère puisque le premier est en position 0) sera copiée dans le tableau désigné par r3.

Réponse

def

Question 4. Même question avec les lignes suivantes.

    char s4[20] = "abcdef";
    strcpy(s4+2,"xy");
    s4[4] = 'z';
    printf("%s\n", s4);
Indice

Il est difficile de visualiser mentalement ce qui ce passe en mémoire. Dans une telle situation il est fortement conseillé de faire un dessin pour localiser précisément les cellules du tableau qui seront impactées par les deuxième et troisième lignes de code.

image-20211231200640341

Réponse

abxyzf

Exercice d’entrainement D.ent2.2

Vous devez implémenter une fonction…

void extract(const char* entree, char balise, char* sortie)

…permettant d’extraire la partie de la chaîne d’entrée situé entre deux caractères balise. La chaîne extraite doit être placée dans le tableau désigné par le paramètre sortie. On suppose que le tableau de sortie a une taille suffisante pour recevoir le résultat, incluant le marqueur de fin de chaîne.

Si le caractère balise n’apparait pas dans la chaîne d’entrée, la chaîne vide doit être placée dans le tableau de sortie. Si le caractère balise apparait une seule fois, tout ce qui est situé après la balise doit être placé dans le tableau de sortie. Si le caractère balise apparaît plus de deux fois, tout ce qui suit la deuxième occurrence doit être ignoré.

Voici un exemple de fonction main qui appelle la fonction extract pour extraire la sous-chaîne située entre deux caractères # dans la chaîne "abcd 12#xyz12#123".

int main()
{
    char entree[] = "abcd 12#xyz12#123";
    char sortie[strlen(entree)+1];
    extract(entree, '#', sortie);
    printf("%s\n", sortie);
    return 0;
}

L’exécution produit l’affichage suivant :

xyz12

Le traitement réalisé par la fonction extract doit être décomposé en trois phases numérotées 1, 2 et 3.

  • La phase 1 dure jusqu’à la lecture de la première occurence de la balise.
  • La phase 2 commence après le lecture de la première occurrence de la balise et se termine au moment de la lecture de la deuxième occurrence de la balise.
  • La phase 3 succède à la phase 2 et termine l’exécution de la fonction après avoir ajouté le marqueur de fin à la fin de la chaîne de sortie.

Voici un squelette du code.

void extract(const char* entree, char balise, char* sortie)
{
    int n = strlen(entree);
    int curseur = 0;                       // Ligne A
    int phase = 1;
    for(int i=0; (i<n) && (phase<3); i++) 
    {
        if(phase==1)
        {
            // Bloc 1
        }
        else if (phase==2)
        {
            if(entree[i]!=balise)
            {
                // Bloc 2
            }
            else
            {
                // Bloc 3
            }
        }
    }
    // Bloc 4
}

En ligne A, la variable curseur représente la position du prochain caractère à écrire dans la chaîne de sortie.

Le bloc 1 lit un caractère dans la chaîne d’entrée et passe en phase 2 si la balise est lue.

Le bloc 2 ajoute à la chaîne de sortie un caractère lu dans la chaîne d’entrée.

Le bloc 3 passe en phase 3, ce qui entrainera l’arrêt de la boucle.

Le bloc 4 ajoute le marqueur de fin à la chaîne de sortie.

Vous devez compléter ces 4 blocs, dont certains ne comportent qu’une seule ligne de code.

Indice1

void extract(const char* entree, char balise, char* sortie)
{
    int n = strlen(entree);
    int curseur = 0;
    int phase = 1;
    for(int i=0; (i<n) && (phase<3); i++)
    {
        if(phase==1)
        {// Avant la première balise
            if(entree[i]==balise) phase = 2;
        }
        else if (phase==2)
        {// Après première balise
            if(entree[i]!=balise)
            {
                // Bloc 2
            }
            else
            {// La deuxième balise est lue
                phase=3;
            }
        }
    }
    sortie[curseur] = 0;
}

Les blocs 1, 3 et 4 ont été pourvus. Il reste le bloc 2 qui est chargé d’ajouter un caractère à la chaîne de sortie.

Solution

void extract(const char* entree, char balise, char* sortie)
{
    int n = strlen(entree);
    int curseur = 0;
    int phase = 1;
    for(int i=0; (i<n) && (phase<3); i++)
    {
        if(phase==1)
        {// Avant la première balise
            if(entree[i]==balise) phase = 2;
        }
        else if (phase==2)
        {// Après première balise
            if(entree[i]!=balise)
            {// Avant deuxième balise
                sortie[curseur] = entree[i];
                curseur++;
            }
            else
            {// La deuxième balise est lue
                phase=3;
            }
        }
    }
    sortie[curseur] = 0;
}

Question supplémentaire.

Implémentez une fonction…

void extract1(char* entree, char balise)

…qui fait la même chose que extract, mais en remplaçant la chaîne d’entrée par la chaîne extraite. Cette fonction doit appeler la fonction extract.

Par exemple, l’exécution de la fonction main suivante…

int main()
{
    char entree[] = "abcd 12#xyz12#123";
    extract1(entree, '#');
    printf("%s\n", entree);
    return 0;
}

…affiche xyz12.

Solution

void extract1(char* entree, char balise)
{
    char sortie[strlen(entree)+1];
    extract(entree, balise, sortie);
    strcpy(entree, sortie);
}

Exercice d’entrainement D.ent2.3

Vous devez implémenter une fonction…

int str2u(const char* str, unsigned* res)

…qui convertit en un entier une chaîne représentant un entier en base 2.

On appelle chaîne d’entrée la chaîne désignée par str. On appelle valeur de sortie (à ne pas confondre avec la valeur de retour) la valeur de la variable pointée par res à l’issue de l’exécution de la fonction. Si la chaîne d’entrée est constituée exclusivement de caractères '0' et / ou '1', la valeur de sortie est l’entier dont la chaîne d’entrée est la représentation en base 2 et la valeur de retour est 1. Dans le cas contraire, la valeur de sortie est indéterminée et la valeur de retour est 0.

Voici un exemple d’utilisation pouvant faire office de test de la fonction.

int main()
{
    char s[] = "011101";
    unsigned resultat;
    int status = str2u(s, &resultat);
    if(status)
    {
        printf("%X\n", resultat);
    }
    else
    {
        printf("Format incorrect\n");
    }

    return 0;
}

La valeur affichée à l’exécution est 1D.

Indice1

Le principe de conversion le plus simple est le suivant :

  • On initialise la valeur de sortie à 0. C’est très important.
  • On utilise une variable poids initialisée à 1.
  • On parcourt la chaîne d’entrée en partant de la fin. Si un caractère autre que '0' ou '1' est lu, on retourne immédiatement 0. Si le caractère '1' est lu, on ajoute poids à la valeur de sortie. À chaque itération, on multiplie poids par 2.

Indice2

Voici une version incomplète de la solution.

int str2u(const char* str, unsigned* res)
{
    unsigned poids = 1;
    *res = 0;
    for(int i=strlen(str)-1; i >= 0; i--)
    {
        if(str[i]=='1')
        {
            // À compléter
        }
        else if(str[i] != '0')
        {
            return 0;
        }
        // À compléter
    }
    return 1;
}

Solution

int str2u(const char* str, unsigned* res)
{
    unsigned poids = 1;
    *res = 0;
    for(int i=strlen(str)-1; i >= 0; i--)
    {
        if(str[i]=='1')
        {
            *res = *res + poids;
        }
        else if(str[i] != '0')
        {
            return 0;
        }
        poids = poids * 2;
    }
    return 1;
}

Question supplémentaire.

Complétez le programme suivant pour qu’il affiche en décimal la valeur binaire saisie en ligne de commande. Si la valeur saisie n’est pas constituée de 0 et 1, le programme affiche Format incorrect. Ce programme doit utiliser la fonction str2u.

int main(int argc, char* argv[])
{
    if(argc != 2)
    {
        printf("Un argument attendu\n");
        exit(1);
    }
    // À compléter
    return 0;
}
Solution

int main(int argc, char* argv[])
{
    if(argc != 2)
    {
        printf("Un argument attendu\n");
        exit(1);
    }
    unsigned resultat;
    int status = str2u(argv[1], &resultat);
    if(status)
    {
        printf("%d\n", resultat);
    }
    else
    {
        printf("Format incorrect\n");
    }
    return 0;
}

Itération D.ent3

Exercice d’entrainement D.ent3.1

Question 1. Sans utiliser de compilateur, donnez les affichages réalisés par l’exécution des lignes de code suivantes.

    char s1[20] = "aaaaaa";
    printf("%s %s %s\n", s1, s1+2, s1+4);          
Réponse

aaaaaa aaaa aa

Les caractères affichés sont ceux compris entre l’adresse désignant la chaîne et le marqueur de fin.

Question 2. Même question avec les lignes suivantes.

    char s2[20] = {0};
    for(int i=0; i<6; i++) s2[i] = 'D'+i;
    printf("%s\n", s2);  
Indice

La notation 'D' désigne à la fois le caractère D et son code ASCII, puisque le langage C ne fait aucune différence entre les deux. Donc 'D'+1 est le code ASCII du caractère E, équivalent à 'E', etc. Comme le tableau est remplis de 0 à l’initialisation, on aura un marqueur de fin immédiatement après le dernier caractère écrit dans le tableau par la boucle for.

Réponse

DEFGHI

Question 3. Même question avec les lignes suivantes.

    char s3[20] = "abcdef";
    char r3[20] = {'X'};
    strcat(r3,s3);
    printf("%s\n", r3);
Indice

Le tableau désigné par r3 est initialisé avec le caractère 'X' suivi de 19 valeur 0. Il faut retenir que lorsqu’un tableau est initialisé, toutes ces cellules reçoivent une valeur et que celles situées au delà des valeurs d’initialisation données explicitement prennent la valeur 0.

Réponse

Xabcdef

Le 0 situé juste après le caractère 'X' fait office de marqueur de fin de chaîne. Le résultat est donc la concaténation des chaînes "X" et "abcdef".

Question 4. Même question avec les lignes suivantes.

    char s4[20] = "abcdef";
	  char* p = s4+2;
    while(*p) {(*p)++; p++;}
    printf("%s\n", s4);
Indice

*p désigne le caractère pointé par p. La condition de contrôle de la boucle while est donc vraie tant que p ne pointe pas le marqueur de fin, c’est à dire que *p est différent de 0. (*p)++ inclémente le code ASCII du caractère pointé alors que p++ incrémente le pointeur.

Réponse

abdefg

Tous les caractères à partir du troisième sont incrémentés.

Exercice d’entrainement D.ent3.2

Vous devez implémenter une fonction…

int supprime(char* str, int pos)

…qui supprime dans la chaîne désignée par str le caractère situé en position pos. Par exemple, si la chaîne est "abcdefghi" et que pos vaut 4, la chaîne devient "abcdfghi". Le caractère 'e', situé en position 4, est supprimé.

Dans un premier temps, implémentez une fonction main qui retire le caractère situé en position 4 dans la chaîne "abcdefghi" et affiche le résultat en supposant que la fonction supprime est correctement définie.

Solution

int main(int argc, char* argv[])
{
    char s[] = "abcdefghi";
    supprime(s, 4);
    printf("%s\n", s);
    return 0;
}

À présent, donnez la définition (le code) de la fonction supprime.

Indice

Ce code est très court. Il suffit de parcourir la chaîne d’entrée entre la position pos et son dernier caractère et d’écrire à chaque position parcourue le caractère situé dans la position suivante.

Solution

int supprime(char* str, int pos)
{
    int n = strlen(str);
    for(int i=pos; i<n; i++)
    {
        str[i] = str[i+1];
    }
}

Exercice d’entrainement D.ent3.3

Vous devez implémenter une fonction…

void afficheMots(const char str[])

…qui affiche tous les mots de la chaîne désignée par str en allant à la ligne après chaque mot. On considère comme étant un mot toute partie de chaîne qui ne commence pas par un espace et qui se termine par un espace ou par le marqueur de fin.

L’exécution de la fonction main suivante…

int main(int argc, char* argv[])
{
    char s[] = "Bonjour tout le monde";
    afficheMots(s);
    return 0;
}

…doit produire l’affichage :

Bonjour
tout
le
monde
Indice1

Il y a plusieurs approches possibles. Celle proposée ici consiste à décomposer le problème à résoudre en utilisant deux fonctions. La fonction à réaliser, afficheMots, appelle une fonction affiche1mot qui est chargée d’afficher chacun des mots.

int affiche1mot(const char str[], int pos)
{
    // À compléter
}

void afficheMots(const char str[])
{
    int i=0;
    while(str[i]!=0)
    {
        i = affiche1mot(str, i);
    }
}

Le code de la fonction afficheMots est donné. Il reste à implémenter la fonction affiche1mot. Cette fonction affiche le mot commençant en position pos dans la chaîne désignée par str. Elle retourne la position du mot suivant ou, si le mot affiché était le dernier, du marqueur de fin.

Indice2

int affiche1mot(const char str[], int pos)
{
    while((str[pos]!=' ')&&(str[pos]!=0))
    {
        // À compléter
    }
    printf("\n");    
    // À compléter
    return pos;
}

Le premier bloc à compléter lit et affiche un caractère du mot en cours d’affichage. Le deuxième bloc à compléter passe les espaces situés après ce mots de manière à ce que la valeur retournée soit la position du début du mot suivant (ou du marqueur de fin de chaîne).

Solution

int affiche1mot(const char str[], int pos)
{
    while((str[pos]!=' ')&&(str[pos]!=0))
    {
        printf("%c",str[pos]);
        pos++;
    }
    printf("\n");    
    while(str[pos]==' ') pos++;
    return pos;
}

void afficheMots(const char str[])
{
    int i=0;
    while(str[i]!=0)
    {
        i = affiche1mot(str, i);
    }
}


Activité de consolidation D.top

Réaliser cette activité consiste à traiter un des exercices de consolidation proposés. Si vous réalisez plusieurs fois cette activité, laissez passer au moins une semaine entre chaque itération et traitez à chaque fois un exercice différent.

Exercice de consolidation D.top1

Vous devez implémenter un programme qui accepte un mot en ligne de commande et qui affiche tous les anagrammes de ce mots. Par exemple, si on nomme le programme ana et qu’on saisi dans la console…

> ana abc

…On obtient l’affichage :

abc
acb
bac
bca
cab
cba
Indice1

La récursivité est votre amie. On peut utiliser la fonction main suivante :

int main(int argc, char* argv[])
{
    if(argc!=2)
    {
        printf("Exactement 1 argument est attendu\n");
        exit(1);
    }
    prefixAna("",argv[1]);
    return 0;
}

Elle appelle la fonction récursive prefixAna que vous devez implémenter :

void prefixAna(const char* prefix, const char* suffix)

Un appel de cette fonction affiche tous les anagrammes de la chaîne désignée par suffix, chacun précédé de la chaîne désignée par prefix. Par exemple, prefixAna("AB", "CD") affiche ABCD et ABDC.

Le principe utilisé est simple mais sa programmation en C est un peu technique.

  • Si le suffixe est vide, le préfixe est affiché.
  • Si le suffixe n’est pas vide, alors pour chaque caractère c du suffixe, on fait un appel récursif prefixAna(p,s) où p est l’ancien préfixe auquel on a ajouté c et ou s est lancien suffixe duquel on a retiré c.

Indice1

void prefixAna(const char* prefix, const char* suffix)
{
    int sizePref = strlen(prefix);        
    int sizeSuff = strlen(suffix);
    if(sizeSuff==0) printf("%s\n",prefix);  // Ligne A
    char nouvPref[sizePref+2];              // Ligne B
    char nouvSuff[sizeSuff];                // Ligne C
    strcpy(nouvPref, prefix);               // Ligne D
    nouvPref[sizePref+1] = 0;               // Ligne E
    nouvSuff[sizeSuff-1] = 0;               // Ligne F
    for(int i = 0; i<sizeSuff; i++)
    {
        // À compléter
    }
}

La ligne A traite le cas trivial dans lequel le suffixe est vide et on affiche juste le préfixe.

Les lignes B et C créent les tableaux qui seront utilisés pour placer les préfixes et les suffixes des appels récursifs. Le nouveau préfixe comportera un caractère de plus que l’ancien et le nouveau suffixe comportera un caractère de moins que l’ancien.

La ligne D recopie l’ancien préfixe dans le tableau qui contiendra les nouveaux préfixes des appels récursifs.

Les lignes E et F placent les marqueurs de fin dans les tableaux qui contiendront les préfixes et suffixes des appels récursifs.

Par exemple, si le préfixe est « AB » et le suffixe « CDE », alors les contenus des tableaux nouvPref et nouvSuff à l’issue de l’exécution de la ligne F sont les suivants :

nouvPref : 'A' 'B'  ?  0
nouvSuff :  ?   ?   0 

Indice2

void prefixAna(const char* prefix, const char* suffix)
{
    int sizePref = strlen(prefix);
    int sizeSuff = strlen(suffix);
    if(sizeSuff==0) printf("--> %s\n",prefix);
    char nouvPref[sizePref+2];
    char nouvSuff[sizeSuff];
    strcpy(nouvPref, prefix);
    nouvPref[sizePref+1] = 0;
    nouvSuff[sizeSuff-1] = 0;
    for(int i = 0; i<sizeSuff; i++)       // Boucle 1
    {
        nouvPref[sizePref] = suffix[i];   // Ligne R
        int k=0;                          // Ligne S
        for(int j=0; j<sizeSuff; j++)     // Boucle 2
        {
            // À compléter
        }
        prefixAna(nouvPref,nouvSuff);     // Ligne T
    }
}

La ligne R ajoute à la fin du nouveau préfixe (celui qui sera utilisé par l’appel récursif), le caractère situé en position i dans l’ancien suffixe.

La ligne S déclare et initialise à 0 la variable k qui indique la position à laquelle sera ajouté chaque caractère au nouveau suffixe lors de sa construction par la boucle 2. À chaque fois qu’un caractère sera ajouté au nouveau suffixe, k sera incrémenté.

La ligne T réalise un appel récursif avec :

  • un nouveau préfixe qui est l’ancien auquel le caractère situé en position i dans l’ancien suffixe est ajouté.
  • un nouveau suffixe qui est l’ancien duquel ce même caractère a été retiré.

Solution

void prefixAna(const char* prefix, const char* suffix)
{
    int sizePref = strlen(prefix);
    int sizeSuff = strlen(suffix);
    if(sizeSuff==0) printf("--> %s\n",prefix);
    char nouvPref[sizePref+2];
    char nouvSuff[sizeSuff];
    strcpy(nouvPref, prefix);
    nouvPref[sizePref+1] = 0;
    nouvSuff[sizeSuff-1] = 0;
    for(int i = 0; i<sizeSuff; i++)
    {
        nouvPref[sizePref] = suffix[i];
        int k=0;
        for(int j=0; j<sizeSuff; j++)
        {
            if(j!=i) 
            {
                nouvSuff[k] = suffix[j];
                k++;
            }
        }
        prefixAna(nouvPref,nouvSuff);
    }
}

int main(int argc, char* argv[])
{
    if(argc!=2)
    {
        printf("Exactement 1 argument est attendu\n");
        exit(1);
    }
    prefixAna("",argv[1]);
    return 0;
}

Exercice de consolidation D.top2

Vous devez implémenter une fonction qui accepte une chaîne en paramètres et qui vérifie si cette chaîne représente un nombre décimal, c’est à dire si elle est constituée d’un signe - optionnel, sauf si le nombre est 0, suivi d’une partie entière, suivie d’une partie décimale optionnelle.

S’il y a une partie décimale, la partie entière est soit vide, soit constituée uniquement du chiffre 0, soit constituée d’un chiffre 1 à 9 suivi d’un nombre quelconque de chiffres 0 à 9. S’il n’y a pas de partie décimale, la partie entière est soit constituée uniquement du chiffre 0, soit constituée d’un chiffre 1 à 9 suivi d’un nombre quelconque de chiffres 0 à 9.

S’il y a une partie entière, la partie décimale est constituée d’un point qui est suivit soit du chiffre 0, soit d’un nombre quelconque non nul de chiffres de 0 à 9. Si la partie entière est vide, la partie décimale est constituée d’un nombre quelconque non nul de chiffres de 0 à 9.

Voici des exemples valides. Tous pourraient être précédés du signe - sauf le premier

0   0.0056   .008   0.09   0.120   12.014  14

Voici des exemples non valides.

00   89.   9.88.0   0067   --0.33   12a.6    

La fonction accepte en paramètre une chaîne de caractère et retourne un entier. La valeur de retour doit être 1 si la chaîne représente un nombre valide et 0 dans le cas contraire.

La fonction main suivante…

int main(int argc, char* argv[])
{
    printf("%d ",verifNbrDec("0"));
    printf("%d ",verifNbrDec("0.0056"));
    printf("%d ",verifNbrDec("0.008"));
    printf("%d ",verifNbrDec("0.09"));
    printf("%d ",verifNbrDec("0.120"));
    printf("%d ",verifNbrDec("12.014"));
    printf("%d\n",verifNbrDec("14"));
    
    printf("%d ",verifNbrDec("00"));
    printf("%d ",verifNbrDec("89."));
    printf("%d ",verifNbrDec("9.88.0"));
    printf("%d ",verifNbrDec("0067"));
    printf("%d ",verifNbrDec("--33"));
    printf("%d\n",verifNbrDec("12a.6"));
    return 0;
}

…devrait afficher :

1 1 1 1 1 1 1
0 0 0 0 0 0

Pour éviter de produire une code très compliqué et très difficile à mettre au point, vous devez baser votre solution sur l’automate fini ci-dessous.

image-20220101234859372

L’état initial est 1. Les états 3, 4 et 6 sont des états d’acceptation, c’est à dire que si, lorsque tous les caractères de la chaîne d’entrée ont été lus, l’automate est dans cet état, alors la chaîne est valide. Les flèches indiquent les transitions autorisées. Par exemple, dans l’état 1, si le caractère 0 est lu alors on passe dans l’état 4, si le caractère - est lu alors on passe dans l’état 2, si un caractère 1 à 9 est lu alors on passe dans l’état 3, et si tout autre caractère est lu, la fonction retourne immédiatement 0.

Indice

Voici un squelette de code à compléter.

int verifNbrDec(const char* str)
{
    int etat = 1;
    int n = strlen(str);
    for(int i=0; i<n; i++)
    {
        char c = str[i];
        if(etat==1)
        {
            // À compléter
        }
        else if(etat==2)
        {
            // À compléter
        }
        else if(etat==3)
        {
            // À compléter
        }
        else if(etat==4)
        {
            // À compléter
        }
        else if(etat==5)
        {
            // À compléter
        }
        else
        {
            // À compléter
        }
    }
    return (etat==3) || (etat==4) || (etat==6);
}

Solution

int verifNbrDec(const char* str)
{
    int etat = 1;
    int n = strlen(str);
    for(int i=0; i<n; i++)
    {
        char c = str[i];
        if(etat==1)
        {
            if(c=='-') etat=2;
            else if(c=='0') etat=4;
            else if((c>='1')&&(c<='9')) etat=3;
            else return 0;
        }
        else if(etat==2)
        {
            if(c=='.') etat=5;
            else if((c>='1')&&(c<='9')) etat=3;
            else return 0;
        }
        else if(etat==3)
        {
            if(c=='.') etat=5;
            else if((c>='0')&&(c<='9')) etat=3;
            else return 0;
        }
        else if(etat==4)
        {
            if(c=='.') etat=5;
            else return 0;
        }
        else if(etat==5)
        {
            if((c>='0')&&(c<='9')) etat=6;
            else return 0;
        }
        else
        {
            if((c>='0')&&(c<='9')) etat=6;
            else return 0;
        }
    }
    return (etat==3) || (etat==4) || (etat==6);
}