{"id":53,"date":"2022-01-03T19:16:56","date_gmt":"2022-01-03T19:16:56","guid":{"rendered":"https:\/\/9h15.net\/activ\/?p=53"},"modified":"2022-02-01T19:24:49","modified_gmt":"2022-02-01T19:24:49","slug":"c-et-c-partie-d","status":"publish","type":"post","link":"https:\/\/9h15.net\/activ\/c-et-c-partie-d\/","title":{"rendered":"C et C++ partie D"},"content":{"rendered":"<p><code>Par O. Bailleux, Ma\u00eetre de conf\u00e9rences HDR \u00e0 l'universit\u00e9 de Bourgogne.<\/code><\/p>\n<h1><a id=\"cha%C3%AEnes-de-caract%C3%A8res-en-c\" class=\"anchor\" aria-hidden=\"true\"><\/a>Cha\u00eenes de caract\u00e8res en C<\/h1>\n<p>Les activit\u00e9s <strong>#.dec<\/strong> (<strong>dec<\/strong> pour D\u00e9couverte) consistent \u00e0 \u00e9tudier des <strong>pr\u00e9sentations explicatives<\/strong> et \u00e0 traiter tous les <strong>exercices de d\u00e9couverte<\/strong> propos\u00e9s. Si vous ne r\u00e9pondez pas correctement \u00e0 un exercice de d\u00e9couverte, revenez en arri\u00e8re pour relire les explications et identifier la cause de votre erreur.<\/p>\n<p>Les activit\u00e9s <strong>#.ent<\/strong> (<strong>ent<\/strong> pour Entrainement) consistent \u00e0 traiter des <strong>exercices d&rsquo;entra\u00eenement<\/strong>. Vous devez d&rsquo;abord tenter de traiter ces exercices sans d\u00e9voiler d&rsquo;indice ni regarder la solution. Vous pouvez remonter dans le document pour relire certaines explications ou consulter les solutions des exercices de d\u00e9couverte ou d&rsquo;entra\u00eenement pr\u00e9c\u00e9demment trait\u00e9s.<\/p>\n<h2><a id=\"activit%C3%A9-de-d%C3%A9couverte-d-dec\" class=\"anchor\" aria-hidden=\"true\"><\/a>Activit\u00e9 de d\u00e9couverte D.dec<\/h2>\n<h3><a id=\"d-dec1-repr%C3%A9sentation-des-cha%C3%AEnes\" class=\"anchor\" aria-hidden=\"true\"><\/a>D.dec1 : Repr\u00e9sentation des cha\u00eenes<\/h3>\n<h4><a id=\"pr%C3%A9requis\" class=\"anchor\" aria-hidden=\"true\"><\/a>Pr\u00e9requis<\/h4>\n<table>\n<thead>\n<tr>\n<th>Partie C : Bien ma\u00eetriser les tableaux, les pointeurs et les fonction traitant des tableaux.<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<h4><a id=\"objectif\" class=\"anchor\" aria-hidden=\"true\"><\/a>Objectif<\/h4>\n<table>\n<thead>\n<tr>\n<th>Repr\u00e9senter et utiliser des cha\u00eenes de caract\u00e8res dans un programme en langage C.<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Les cha\u00eenes de caract\u00e8res ont de nombreuses utilisations possibles. Elle permettent la prise en compte d&rsquo;informations exprim\u00e9es en langage naturel et d&rsquo;une mani\u00e8re plus g\u00e9n\u00e9rale de donn\u00e9es qui ne sont pas num\u00e9riques ou ne sont pas initialement repr\u00e9sent\u00e9es par des types num\u00e9riques. On a donc besoin de les repr\u00e9senter, de les stocker, de les afficher.<\/p>\n<h4><a id=\"moyen\" class=\"anchor\" aria-hidden=\"true\"><\/a>Moyen<\/h4>\n<table>\n<thead>\n<tr>\n<th>Les cha\u00eenes sont repr\u00e9sent\u00e9es par des tableaux de caract\u00e8res.<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Il n&rsquo;y a pas de type pour les cha\u00eenes de caract\u00e8res en langage C, mais une <strong>convention de repr\u00e9sentation<\/strong> : une cha\u00eene est repr\u00e9sent\u00e9e par une suite de caract\u00e8res termin\u00e9e par un <strong>marqueur de fin de cha\u00eene<\/strong> et stock\u00e9e dans un tableau de caract\u00e8res.<\/p>\n<p>Pour bien comprendre de quoi on parle, il faut se rappeler qu&rsquo;il existe un type <code>char<\/code> qui repr\u00e9sente des entiers sign\u00e9s cod\u00e9es sur 8 bits et qui peut <strong>aussi<\/strong> \u00eatre utilis\u00e9 pour repr\u00e9senter des caract\u00e8res. L&rsquo;ex\u00e9cution des lignes suivantes&#8230;<\/p>\n<pre><code class=\"language-c\">char c = 'H';             \/\/ Ligne A\nprintf(\"%x %c\\n\",c, c);   \/\/ Ligne B\nc = 35;                   \/\/ Ligne C\nprintf(\"%x %c\\n\",c, c);   \/\/ Ligne D\n<\/code><\/pre>\n<p>&#8230;produit l&rsquo;affichage :<\/p>\n<pre><code class=\"language-plain_text\">48 H\n23 #\n<\/code><\/pre>\n<p><strong>En ligne A<\/strong>, la variable <code>c<\/code> est initialis\u00e9e avec le code <code>ASCII<\/code> du caract\u00e8re <code>'H'<\/code>.<\/p>\n<p><strong>En ligne B<\/strong>, la valeur de cette variable est affich\u00e9e deux fois, dans deux formats diff\u00e9rents : en hexad\u00e9cimal et sous forme de caract\u00e8re. 48 est la repr\u00e9sentation hexad\u00e9cimale du code <code>ASCII<\/code> de <code>'H'<\/code>.<\/p>\n<p><strong>En ligne C<\/strong>, la <strong>m\u00eame<\/strong> variable re\u00e7oit l&rsquo;entier dont la repr\u00e9sentation d\u00e9cimale est 35. Dans n&rsquo;importe quel autre langage, \u00e0 part peut-\u00eatre l&rsquo;assembleur, ce serait impensable de faire cela. Mais pour le compilateur C il n&rsquo;y a aucun probl\u00e8me, puisque les caract\u00e8res <strong>sont<\/strong> des entiers.<\/p>\n<p><strong>En ligne D<\/strong>, on affiche deux fois la valeur de la variable <code>c<\/code>, dans deux formats diff\u00e9rents : en hexad\u00e9cimal et sous forme de caract\u00e8re. Le nombre entier not\u00e9 35 en d\u00e9cimal se note 23 en hexad\u00e9cimal, et c&rsquo;est par ailleurs le code <code>ASCII<\/code> du caract\u00e8re <code>'#'<\/code>.<\/p>\n<h5><a id=\"exercice-de-d%C3%A9couverte-d-dec-x1\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte D.dec.x1<\/h5>\n<p>Sans utiliser de compilateur <strong>ni de table de codes <code>ASCII<\/code><\/strong>, tentez de d\u00e9terminer les valeurs affich\u00e9es par l&rsquo;ex\u00e9cution de ces lignes de code.<\/p>\n<pre><code class=\"language-c\">printf(\"%d \",'H' - 'A');\nprintf(\"%c\\n\", 'a' + 3);\n<\/code><\/pre>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-plain_text\">7 d\n<\/code><\/pre>\n<p>Les codes <code>ASCII<\/code> des lettres majuscules se suivent. Le code <code>ASCII<\/code> de <code>'H'<\/code> est donc \u00e9gal \u00e0 celui de <code>'A'<\/code> plus 7. La diff\u00e9rence entre les deux vaut 7, et il n&rsquo;est pas n\u00e9cessaire de conna\u00eetre les codes de <code>'A'<\/code> et de <code>'H'<\/code> pour le d\u00e9duire.<\/p>\n<p>D&rsquo;autre part, les codes <code>ASCII<\/code> des lettres minuscules se suivent. Donc si on ajoute 3 au code <code>ASCII<\/code> de <code>'a'<\/code>, on obtient le code ASCII de <code>'d'<\/code>.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<p>Le deuxi\u00e8me point important \u00e0 comprendre est le principe de repr\u00e9sentation des cha\u00eenes. Examinons un exemple.<\/p>\n<p>La fonction suivante permet d&rsquo;afficher en hexad\u00e9cimal les <code>n<\/code> premi\u00e8res valeurs du tableau de caract\u00e8res d\u00e9sign\u00e9 par <code>tab<\/code>.<\/p>\n<pre><code class=\"language-c\">void printHex(char tab[], int n)\n{\n    for(int i=0; i&lt;n; i++)      \n    {\n        printf(\"%02x \", tab[i]);\n    }\n    printf(\"\\n\");\n}\n<\/code><\/pre>\n<p>Si vous ma\u00eetrisez les pr\u00e9requis (parties A, B et C), la compr\u00e9hension de son fonctionnement ne doit pas vous poser de probl\u00e8me. Maintenant, on d\u00e9finit la fonction main suivante.<\/p>\n<pre><code class=\"language-c\">int main()\n{\n    char s[11] = \"Tim et Tom\";   \/\/ Ligne A\n    printHex(s,11);              \/\/ Ligne B\n    printf(\"%s\\n\", s);           \/\/ Ligne C \n    s[3] = 0;                    \/\/ Ligne D\n    printf(\"%s\\n\", s);           \/\/ Ligne E \n    printHex(s,11);              \/\/ Ligne F\n}\n<\/code><\/pre>\n<p>L&rsquo;affichage obtenu est :<\/p>\n<pre><code class=\"language-plain_text\">54 69 6d 20 65 74 20 54 6f 6d 00 \nTim et Tom\nTim\n54 69 6d 00 65 74 20 54 6f 6d 00 \n<\/code><\/pre>\n<p><strong>La ligne A<\/strong> cr\u00e9e un tableau de 11 caract\u00e8res et l&rsquo;initialise en y pla\u00e7ant la cha\u00eene <code>\"Tim et Tom\"<\/code>.<\/p>\n<p><strong>La ligne B<\/strong> affiche le d\u00e9tail du contenu du tableau. On y voit les codes <code>ASCII<\/code> des caract\u00e8res de la cha\u00eene suivis de la valeur 0. ceci nous permet de comprendre deux choses :<\/p>\n<ol>\n<li>Le compilateur a traduit la notation entre double cotes de la ligne A en une suite de caract\u00e8res qui ont \u00e9t\u00e9 plac\u00e9s dans les cellules du tableau.<\/li>\n<li><strong>La valeur 0<\/strong>, qui est affich\u00e9e sous la forme 00 car la fonction <code>printHex<\/code> affiche toutes les valeurs avec deux chiffres pour des raisons purement esth\u00e9tiques, fait office de <strong>marqueur de fin de cha\u00eene<\/strong>. Attention, il s&rsquo;agit bien de la <strong>valeur 0 et pas du caract\u00e8re <code>'0'<\/code><\/strong>.<\/li>\n<\/ol>\n<p><strong>La ligne C<\/strong> nous montre que <code>printf<\/code> peut afficher des cha\u00eenes si on le lui demande en utilisant le format d&rsquo;affichage <code>%s<\/code>. Elle produit l&rsquo;affichage <code>\"Tim et Tom\"<\/code>. Le marqueur de fin de cha\u00eene n&rsquo;est pas affich\u00e9.<\/p>\n<p><strong>La ligne D<\/strong> place un marqueur de fin de cha\u00eene juste apr\u00e8s <code>\"Tim\"<\/code>.<\/p>\n<p><strong>La ligne E<\/strong> affiche \u00e0 nouveau la cha\u00eene d\u00e9sign\u00e9e par <code>s<\/code>, et cette fois-ci seul <code>\"Tim\"<\/code> est affich\u00e9.<\/p>\n<p><strong>La ligne F<\/strong> permet de voir la nouvelle repr\u00e9sentation en m\u00e9moire. Les caract\u00e8res repr\u00e9sentant la fin de la cha\u00eene initiale sont toujours l\u00e0, mais il ne sont pas affich\u00e9s car <code>printf<\/code>, avec le format <code>%s<\/code>, arr\u00eate l&rsquo;affichage d\u00e8s la premi\u00e8re occurrence du marqueur de fin de cha\u00eene et ignore tout ce qui suit.<\/p>\n<p>Une conclusion s&rsquo;impose : <strong>une cha\u00eene peut \u00eatre plus petite que le tableau qui la contient<\/strong>. Par contre ce serait une tr\u00e8s mauvaise id\u00e9e de placer dans un tableau une cha\u00eene plus grande (en incluant le marqueur de fin) que la taille de ce tableau.<\/p>\n<h5><a id=\"exercice-de-d%C3%A9couverte-d-dec-x2\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte D.dec.x2<\/h5>\n<p>Sans utiliser de compilateur, donnez les affichages produits par ces lignes de code.<\/p>\n<pre><code class=\"language-c\">char s[] = {'0','0','0',0};\nprintf(\"%s\\n\", s);\ns[0] = 0;\nprintf(\"%s\\n\", s);\n<\/code><\/pre>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-plain_text\">000\n\n<\/code><\/pre>\n<p>Le premier appel \u00e0 <code>printf<\/code> affiche la cha\u00eene constitu\u00e9e de trois caract\u00e8res <code>'0'<\/code>. Ensuite, le marqueur de fin est plac\u00e9 en d\u00e9but du tableau, ce qui transforme la cha\u00eene contenue dans ce tableau en cha\u00eene vide. Donc le deuxi\u00e8me <code>printf<\/code> n&rsquo;affiche rien.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h5><a id=\"exercice-de-d%C3%A9couverte-d-dec-x3\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte D.dec.x3<\/h5>\n<p>\u00c0 la compilation, une des lignes de codes suivantes produit une erreur. Laquelle, et pourquoi ?<\/p>\n<pre><code class=\"language-c\">char str[10] = \"Tim\";   \/\/ Ligne A\nprintf(\"%s\\n\", str);    \/\/ Ligne B\nstr = \"Tom\";            \/\/ Ligne C\nprintf(\"%s\\n\", str);    \/\/ Ligne D\n<\/code><\/pre>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>La ligne C est incorrecte car on ne peut pas utiliser <code>=<\/code> pour assigner un tableau, mais seulement pour assigner une de ces cellules. L&rsquo;utilisation de <code>=<\/code> en ligne A est autoris\u00e9e car il s&rsquo;agit d&rsquo;une <strong>initialisation<\/strong> qui est r\u00e9alis\u00e9e au moment de la cr\u00e9ation du tableau.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h5><a id=\"exercice-de-d%C3%A9couverte-d-dec-x4\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte D.dec.x4<\/h5>\n<p>Quel affichage est produit par l&rsquo;ex\u00e9cution des lignes de code suivantes et pourquoi ?<\/p>\n<pre><code class=\"language-c\">char s1[] = \"Tim\";\nchar s2[] = \"Tim\";\nif(s1 == s2) printf(\"Yes\\n\");\nelse printf(\"No\\n\");\n<\/code><\/pre>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>L&rsquo;affichage est <code>No<\/code> car pour le compilateur, s1 et s2 sont les <strong>adresses m\u00e9moire<\/strong> des tableaux contenant les deux cha\u00eenes. C&rsquo;est une cons\u00e9quence directe de la correspondance entre pointeurs et tableaux qui a \u00e9t\u00e9 expliqu\u00e9e dans la partie pr\u00e9c\u00e9dente. La notation <code>s1 == s2<\/code> compare les adresses m\u00e9moire de deux tableaux diff\u00e9rents ayant le m\u00eame contenu. Le r\u00e9sultat est la valeur Bool\u00e9enne false (repr\u00e9sent\u00e9e, pour m\u00e9moire, par l&rsquo;entier 0).<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h5><a id=\"r%C3%A9capitulons\" class=\"anchor\" aria-hidden=\"true\"><\/a>R\u00e9capitulons<\/h5>\n<ul>\n<li>Une cha\u00eene est repr\u00e9sent\u00e9e par des suites de caract\u00e8res situ\u00e9es dans un tableau et termin\u00e9es par un marqueur de fin de cha\u00eene qui est l&rsquo;entier 0 (au format <code>char<\/code>, c&rsquo;est \u00e0 dire cod\u00e9 sur 8 bits).<\/li>\n<li>Une cha\u00eene peut \u00eatre plus petite que le tableau qui la contient. Les caract\u00e8res situ\u00e9s apr\u00e8s le marqueur de fin ne sont pas significatifs.<\/li>\n<li>Une cha\u00eene peut \u00eatre repr\u00e9sent\u00e9e, dans un code source, entre double cotes, comme par exemple <code>\"Tim\"<\/code>. On parle de <strong>cha\u00eene litt\u00e9rale<\/strong>.<\/li>\n<li>Un tableau de caract\u00e8res peut \u00eatre initialis\u00e9 avec une cha\u00eene de caract\u00e8res en utilisant <code>=<\/code> et la notation entre double cotes.<\/li>\n<li>Le format <code>%s<\/code> permet \u00e0 <code>printf<\/code> d&rsquo;afficher des cha\u00eenes de caract\u00e8res.<\/li>\n<\/ul>\n<h4><a id=\"bonus\" class=\"anchor\" aria-hidden=\"true\"><\/a>Bonus<\/h4>\n<table>\n<thead>\n<tr>\n<th>Quelques subtilit\u00e9s<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<h5><a id=\"caract%C3%A8res-d%C3%A9-chappement\" class=\"anchor\" aria-hidden=\"true\"><\/a>Caract\u00e8res d&rsquo;\u00e9chappement<\/h5>\n<p>Le marqueur de fin de cha\u00eene, c&rsquo;est \u00e0 dire l&rsquo;entier 0, n&rsquo;est pas un caract\u00e8re imprimable. Il peut \u00eatre aussi repr\u00e9sent\u00e9 avec la notation <code>'\\0'<\/code>. Il existe d&rsquo;autres caract\u00e8res sp\u00e9ciaux tels que <code>'\\n'<\/code>, indiquant un retour \u00e0 la ligne, que nous avons d\u00e9j\u00e0 souvent utilis\u00e9, <code>'\\t'<\/code> qui repr\u00e9sente la tabulation, et <code>'\\a'<\/code> qui \u00e9met un beep sonore !<\/p>\n<h5><a id=\"zones-de-stockage-des-cha%C3%AEnes\" class=\"anchor\" aria-hidden=\"true\"><\/a>Zones de stockage des cha\u00eenes<\/h5>\n<p>Examinons les lignes de code suivantes.<\/p>\n<pre><code class=\"language-c\">    char s1[] = \"Tim\";     \/\/ Ligne A\n    char* s2 = \"Tom\";      \/\/ Ligne B\n    printf(\"%s et %s\\n\", s1, s2);\n<\/code><\/pre>\n<p>Leur ex\u00e9cution a pour effet l&rsquo;affichage <code>Tim et Tom<\/code>. Il semble donc y avoir deux mani\u00e8res d&rsquo;initialiser un tableau avec une cha\u00eene de caract\u00e8res. Mais si ensuite on \u00e9crit&#8230;<\/p>\n<pre><code class=\"language-c\">    s1[0] = 'X';           \/\/ Ligne C\n    s2[0] = 'X';           \/\/ Ligne D\n    printf(\"%s et %s\\n\", s1, s2);\n<\/code><\/pre>\n<p>&#8230;il peut se produire des choses f\u00e2cheuses, tel que par exemple un arr\u00eat du programme avant la fin de son ex\u00e9cution. Voici l&rsquo;explication.<\/p>\n<p><strong>En ligne A<\/strong>, on cr\u00e9e un tableau de caract\u00e8res situ\u00e9 dans la pile et on l&rsquo;initialise avec une cha\u00eene. Ce tableau est modifiable, c&rsquo;est \u00e0 dire que son contenu peut changer au cours de l&rsquo;ex\u00e9cution de la fonction \u00e0 laquelle il appartient.<\/p>\n<p><strong>En ligne B<\/strong>, on cr\u00e9e un tableau de caract\u00e8res situ\u00e9 dans une zone m\u00e9moire d\u00e9di\u00e9es au stockage de donn\u00e9es non modifiables. Ce tableau ne peut pas \u00eatre modifi\u00e9. La cha\u00eene qu&rsquo;il contient est une constante.<\/p>\n<p><strong>En ligne D<\/strong>, on tente de modifier le premier caract\u00e8re de la cha\u00eene constante. Cela peut fonctionner sur certains syst\u00e8mes anciens, rudimentaires ou permissifs, mais avec les syst\u00e8mes modernes, cela provoque une erreur d&rsquo;ex\u00e9cution.<\/p>\n<p>D&rsquo;ailleurs, la bonne mani\u00e8re d&rsquo;\u00e9crire la ligne B est la suivante :<\/p>\n<pre><code class=\"language-c\">    const char* s2 = \"Tom\";\n<\/code><\/pre>\n<p>Ainsi, la tentative de modification de la ligne D provoque une erreur \u00e0 la compilation et non lors de l&rsquo;ex\u00e9cution.<\/p>\n<h5><a id=\"attention%C3%A0-la-taille-du-tableau-de-stockage\" class=\"anchor\" aria-hidden=\"true\"><\/a>Attention \u00e0 la taille du tableau de stockage<\/h5>\n<p>Pour dimensionner une tableau destin\u00e9 \u00e0 contenir une cha\u00eene, il faut toujours penser au marqueur de fin. Par exemple dans les lignes de code suivantes&#8230;<\/p>\n<pre><code class=\"language-c\">    char s[3] = \"Tim\";\n    printf(\"%s\\n\", s);\n<\/code><\/pre>\n<p>&#8230;Il y a une erreur. Le tableau d\u00e9sign\u00e9 par <code>s<\/code> comporte trois cellules, mais il en faut 4 pour stocker la cha\u00eene <code>\"Tim\"<\/code> et son marqueur de fin. Le compilateur que j&rsquo;ai utilis\u00e9 n&rsquo;y a vu que du feu, et le programme fonctionne, mais \u00e0 l&rsquo;ex\u00e9cution, la valeur 0 est \u00e9crite au del\u00e0 de la fin du tableau. Cette erreur peut passer compl\u00e8tement inaper\u00e7ue \u00e0 l&rsquo;ex\u00e9cution, mais peut occasionnellement provoquer un dysfonctionnement grave du programme. Un programme en langage C ne doit en aucun cas comporter ce genre d&rsquo;erreur.<\/p>\n<p>Si on \u00e9crit&#8230;<\/p>\n<pre><code class=\"language-c\">    char s[] = \"Tim\";\n<\/code><\/pre>\n<p>&#8230;le compilateur cr\u00e9e un tableau de 4 caract\u00e8res et l&rsquo;initialise correctement.<\/p>\n<h3><a id=\"d-dec2-fonctions-standards-relatives-aux-cha%C3%AEnes\" class=\"anchor\" aria-hidden=\"true\"><\/a>D.dec2 : Fonctions standards relatives aux cha\u00eenes<\/h3>\n<h4><a id=\"pr%C3%A9requis\" class=\"anchor\" aria-hidden=\"true\"><\/a>Pr\u00e9requis<\/h4>\n<table>\n<thead>\n<tr>\n<th>Bien ma\u00eetriser la partie pr\u00e9c\u00e9dente.<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<h4><a id=\"objectif\" class=\"anchor\" aria-hidden=\"true\"><\/a>Objectif<\/h4>\n<table>\n<thead>\n<tr>\n<th>Faciliter des op\u00e9rations utilis\u00e9es fr\u00e9quemment avec des cha\u00eenes, telles que la comparaison, la copie, la concat\u00e9nation&#8230;<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Nous avons vu que l&rsquo;op\u00e9rateur d&rsquo;assignation <code>=<\/code> ne permet <strong>pas<\/strong> de copier une cha\u00eene dans un tableau de caract\u00e8re existant (il permet juste d&rsquo;initialiser un tableau lors de sa d\u00e9claration). Nous avons \u00e9galement vu que l&rsquo;op\u00e9rateur <code>==<\/code> ne permet <strong>pas<\/strong> de comparer les contenus de deux cha\u00eenes, mais seulement leurs adresses m\u00e9moire. Nous savons aussi que disposer de l&rsquo;adresse d&rsquo;un tableau ne nous permet <strong>pas<\/strong> de connaitre sa taille, et que de toutes fa\u00e7ons, une cha\u00eene peut \u00eatre plus courte que le tableau qui la contient. Pour connaitre la longueur d&rsquo;une cha\u00eene, il faut donc compter les caract\u00e8res situ\u00e9s avant la marqueur de fin. Pour simplifier ces op\u00e9rations et d&rsquo;autres particuli\u00e8rement utiles, il existe des <strong>fonctions standards<\/strong> d\u00e9di\u00e9es au traitement des cha\u00eenes. Elle sont d\u00e9clar\u00e9es dans le fichier d&rsquo;ent\u00eate <code>string.h<\/code>.<\/p>\n<h4><a id=\"moyen\" class=\"anchor\" aria-hidden=\"true\"><\/a>Moyen<\/h4>\n<table>\n<thead>\n<tr>\n<th>Quelques fonctions standards tr\u00e8s utiles<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Seules les fonctions les plus couramment utilis\u00e9es sont pr\u00e9sent\u00e9es ici. Vous pourrez en trouver d&rsquo;autres en consultant des sources documentaires telles que <a href=\"https:\/\/koor.fr\/C\/cstring\/cstring.wp\">Koor.fr<\/a> ou encore <a href=\"https:\/\/fr.wikibooks.org\/wiki\/Programmation_C\">le wiki livre sur la programmation C<\/a>.<\/p>\n<h5><a id=\"longueur-d-une-cha%C3%AEne\" class=\"anchor\" aria-hidden=\"true\"><\/a>Longueur d&rsquo;une cha\u00eene<\/h5>\n<pre><code class=\"language-c\">    size_t strlen( const char * theString );\n<\/code><\/pre>\n<p>Retourne la longueur de la cha\u00eene d\u00e9sign\u00e9e par le param\u00e8tre <code>theString<\/code>. La valeur de retour est un entier long non sign\u00e9 (type <code>size_t<\/code>), mais sauf si vous utilisez des cha\u00eenes de plus de 2 milliards de caract\u00e8res, le r\u00e9sultat peut \u00eatre \u00ab\u00a0cast\u00e9\u00a0\u00bb en <code>int<\/code>.<\/p>\n<pre><code class=\"language-c\">    char s[] = \"Tim\";\n    int longueur = (int)strlen(s);\n    printf(\"%d\\n\", longueur);\n<\/code><\/pre>\n<h5><a id=\"copie-d-une-cha%C3%AEne\" class=\"anchor\" aria-hidden=\"true\"><\/a>Copie d&rsquo;une cha\u00eene<\/h5>\n<pre><code class=\"language-c\">char * strcpy( char * destination, const char * source );\nchar * strncpy( char * destination, const char * source, size_t length );\n<\/code><\/pre>\n<p>La premi\u00e8re version copie la cha\u00eene d\u00e9sign\u00e9 par <code>source<\/code> dans le tableau d\u00e9sign\u00e9 par <code>destination<\/code>. Il faut imp\u00e9rativement que le tableau de destination ait une taille suffisante pour contenir la cha\u00eene copi\u00e9e en incluant (comme toujours !) son marqueur de fin. Aucune v\u00e9rification n&rsquo;est faite par la fonction. La valeur de retour est l&rsquo;adresse du tableau de destination. C&rsquo;est une information redondante (puisque cette adresse est donn\u00e9e en param\u00e8tre) qu&rsquo;il vaut mieux <strong>ignorer<\/strong>. Le marqueur de fin est copi\u00e9.<\/p>\n<p>La deuxi\u00e8me version a un param\u00e8tre suppl\u00e9mentaire qui limite le nombre de caract\u00e8res \u00e0 copier. Dans le cas o\u00f9 la cha\u00eene source est trop grande pour \u00eatre compl\u00e8tement copi\u00e9e, le marqueur de fin n&rsquo;est <strong>pas<\/strong> ajout\u00e9 \u00e0 la cha\u00eene de destination.<\/p>\n<h5><a id=\"exercice-de-d%C3%A9couverte-d-dec-x5\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte D.dec.x5<\/h5>\n<p>Quels sont les affichages r\u00e9alis\u00e9s par l&rsquo;ex\u00e9cution des lignes de code suivantes ?<\/p>\n<pre><code class=\"language-c\">    char s[10] = \"aaaaa\";\n    strcpy(s+3, \"bbbbb\");\n    printf(\"%s\\n\", s);\n<\/code><\/pre>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-plain_text\">aaabbbbb\n<\/code><\/pre>\n<p>L&rsquo;adresse de destination de la copie, <code>s+3<\/code>, est celle de la quatri\u00e8me cellule du tableau d\u00e9sign\u00e9 par <code>s<\/code>. (Pour m\u00e9moire, <code>s<\/code> ou <code>s+0<\/code> est l&rsquo;adresse de la premi\u00e8re cellule.) Ceci est une cons\u00e9quence de l&rsquo;arithm\u00e9tique des pointeurs et de la correspondance entre tableaux et pointeurs, qui sont des notions fondamentales. La copie de la cha\u00eene source ne recouvre donc que partiellement la cha\u00eene de destination initiale.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h5><a id=\"concat%C3%A9nation\" class=\"anchor\" aria-hidden=\"true\"><\/a>Concat\u00e9nation<\/h5>\n<pre><code class=\"language-c\">char * strcat( char * destination, const char * source );\nchar * strncat( char * destination, const char * source, size_t size  );\n<\/code><\/pre>\n<p>La premi\u00e8re version ajoute la cha\u00eene d\u00e9sign\u00e9 par <code>source<\/code> \u00e0 la fin de la cha\u00eene situ\u00e9e dans le tableau d\u00e9sign\u00e9 par <code>destination<\/code>. Il faut imp\u00e9rativement que le tableau de destination ait une taille suffisante pour contenir le r\u00e9sultat en incluant (comme toujours !) son marqueur de fin. Aucune v\u00e9rification n&rsquo;est faite par la fonction. La valeur de retour est l&rsquo;adresse du tableau de destination. C&rsquo;est une information redondante (puisque cette adresse est donn\u00e9e en param\u00e8tre) qu&rsquo;il vaut mieux <strong>ignorer<\/strong>. Un marqueur de fin est ajout\u00e9 \u00e0 la cha\u00eene de destination.<\/p>\n<p>La deuxi\u00e8me version a un param\u00e8tre suppl\u00e9mentaire qui limite le nombre de caract\u00e8res \u00e0 copier. Dans le cas o\u00f9 la cha\u00eene source est trop grande pour \u00eatre compl\u00e8tement copi\u00e9e, le marqueur de fin n&rsquo;est <strong>pas<\/strong> ajout\u00e9 \u00e0 la cha\u00eene de destination.<\/p>\n<h5><a id=\"exercice-de-d%C3%A9couverte-d-dec-x6\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte D.dec.x6<\/h5>\n<p>Soit la ligne de code suivante.<\/p>\n<pre><code class=\"language-c\">    char s[10] = \"abc\";\n<\/code><\/pre>\n<p>Quelle ligne faut-il ajouter pour concat\u00e9ner la cha\u00eene <code>\"def\"<\/code> \u00e0 celle d\u00e9j\u00e0 pr\u00e9sente dans le tableau d\u00e9sign\u00e9 par <code>s<\/code> ?<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\">    strcat(s, \"def\");\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h5><a id=\"exercice-de-d%C3%A9couverte-d-dec-x7\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte D.dec.x7<\/h5>\n<p>Examinez les lignes de code suivantes.<\/p>\n<pre><code class=\"language-c\">    char s[10] = \"abcde\";\n    strcat(s, \"fghij\");\n    printf(\"%s\\n\", s);\n<\/code><\/pre>\n<p>Y-a-t&rsquo;il une erreur ? Et si oui laquelle ?<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>Il y a une erreur. La concat\u00e9nation des deux cha\u00eenes occupe 11 caract\u00e8res en comptant le marqueur de fin. Il n&rsquo;y a pas assez de place dans le tableau de destination.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h5><a id=\"comparaison\" class=\"anchor\" aria-hidden=\"true\"><\/a>Comparaison<\/h5>\n<pre><code class=\"language-c\">int strcmp( const char * first, const char * second );\n<\/code><\/pre>\n<p>Cette fonction compare les chaines d\u00e9sign\u00e9es par les deux param\u00e8tres sur la base de l&rsquo;ordre lexicographique des codes <code>ASCII<\/code>. Dans cet ordre, les chiffres sont situ\u00e9s avant les lettre majuscules, qui sont situ\u00e9es avant les lettres minuscules. La valeur de retour est n\u00e9gative si la premi\u00e8re cha\u00eene est situ\u00e9e avant la deuxi\u00e8me dans l&rsquo;ordre lexicographique, elle vaut 0 si les deux cha\u00eenes sont identiques, sinon elle est positive.<\/p>\n<h5><a id=\"exercice-de-d%C3%A9couverte-d-dec-x8\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte D.dec.x8<\/h5>\n<p>Indiquez, pour chacune des lignes de code suivantes, si elle affiche une valeur n\u00e9gative, positive ou nulle.<\/p>\n<pre><code class=\"language-c\">    printf(\"%d\\n\", strcmp(\"abc\", \"Abc\"));\n    printf(\"%d\\n\", strcmp(\"ab\", \"abc\"));\n    printf(\"%d\\n\", strcmp(\"ab\", \"a123\"));\n<\/code><\/pre>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-plain_text\">1 -1 1\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h3><a id=\"d-dec3-conception-de-fonctions-traitant-des-cha%C3%AEnes\" class=\"anchor\" aria-hidden=\"true\"><\/a>D.dec3 : Conception de fonctions traitant des cha\u00eenes<\/h3>\n<h4><a id=\"pr%C3%A9requis\" class=\"anchor\" aria-hidden=\"true\"><\/a>Pr\u00e9requis<\/h4>\n<table>\n<thead>\n<tr>\n<th>Ma\u00eetriser les pointeurs et tableaux et avoir bien compris les notions introduites dans les sections pr\u00e9c\u00e9dentes.<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<h4><a id=\"objectif\" class=\"anchor\" aria-hidden=\"true\"><\/a>Objectif<\/h4>\n<table>\n<thead>\n<tr>\n<th>R\u00e9aliser des fonctions acceptant des cha\u00eenes en param\u00e8tres et capable de r\u00e9aliser des traitements sur ces cha\u00eenes<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Les fonctions standards r\u00e9pondent \u00e0 des besoins courants, mais il arrive souvent qu&rsquo;un d\u00e9veloppeur doivent r\u00e9aliser des traitements sp\u00e9cifiques pour lesquels il est souhaitable de d\u00e9finir des fonctions pouvant \u00eatre utilis\u00e9es autant de fois que n\u00e9cessaire sans duplication de code.<\/p>\n<h4><a id=\"moyen\" class=\"anchor\" aria-hidden=\"true\"><\/a>Moyen<\/h4>\n<table>\n<thead>\n<tr>\n<th>Param\u00e8tres de type pointeurs sur des tableaux<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Les techniques vues dans la partie C \u00e0 propos du passage de tableaux en param\u00e8tres (plus exactement de pointeurs d\u00e9signant des tableaux) sont directement applicables aux fonctions devant r\u00e9aliser des traitements sur des cha\u00eenes de caract\u00e8res. C&rsquo;est m\u00eame plus simple car contrairement aux tableaux d&rsquo;usage g\u00e9n\u00e9ral dont on ne peut retrouver la taille \u00e0 partir de leurs adresses, on peut connaitre la longueur d&rsquo;une cha\u00eene de caract\u00e8res \u00e0 l&rsquo;aide de la fonction <code>strlen<\/code> vue pr\u00e9c\u00e9demment.<\/p>\n<p>Examinons un exemple pas \u00e0 pas. Nous nous fixons pour objectif de r\u00e9aliser une fonction <code>filtre<\/code> qui produit une cha\u00eene de sortie obtenue en retirant d&rsquo;une cha\u00eene d&rsquo;entr\u00e9e les caract\u00e8res autres que les chiffres et les lettres (minuscules et majuscules).<\/p>\n<h5><a id=\"transmettre-la-cha%C3%AEne-d-entr%C3%A9e%C3%A0-la-fonction\" class=\"anchor\" aria-hidden=\"true\"><\/a>Transmettre la cha\u00eene d&rsquo;entr\u00e9e \u00e0 la fonction<\/h5>\n<p>Il est naturel de passer en param\u00e8tre la cha\u00eene d&rsquo;entr\u00e9e, sous la forme d&rsquo;un pointeur. C&rsquo;est la mani\u00e8re habituelle de proc\u00e9der avec les fonctions agissant sur des tableaux, or les cha\u00eenes sont des tableaux de caract\u00e8res.<\/p>\n<h5><a id=\"r%C3%A9cup%C3%A9rer-la-cha%C3%AEne-de-sortie\" class=\"anchor\" aria-hidden=\"true\"><\/a>R\u00e9cup\u00e9rer la cha\u00eene de sortie<\/h5>\n<p>Il pourrait sembler naturel de faire en sorte que la fonction \u00e0 r\u00e9aliser retourne la cha\u00eene de sortie. Mais c&rsquo;est une mauvaise id\u00e9e car une fonction ne peut retourner que l&rsquo;adresse d&rsquo;un tableau et non son contenu. C&rsquo;est une limitation du langage C. De plus <strong>une fonction ne doit en aucun cas retourner l&rsquo;adresse d&rsquo;une des ses variables locales<\/strong>, car la dite variable n&rsquo;existe plus \u00e0 l&rsquo;issue de l&rsquo;ex\u00e9cution de la fonction.<\/p>\n<p>La solution consiste \u00e0 transmettre deux tableaux en param\u00e8tre : un contenant la cha\u00eene d&rsquo;entr\u00e9e et l&rsquo;autre destin\u00e9 \u00e0 r\u00e9cup\u00e9rer la cha\u00eene de sortie. La personne \u00e9crivant du code qui appelle la fonction devra imp\u00e9rativement faire en sorte que la taille du tableau de sortie soit suffisante pour recevoir le r\u00e9sultat.<\/p>\n<p>Voici un exemple avec une fonction <code>recopie<\/code> qui se contente de donner la cha\u00eene d&rsquo;entr\u00e9e non modifi\u00e9e comme r\u00e9sultat et une fonction main qui montre comment appeler la fonction <code>recopie<\/code>.<\/p>\n<pre><code class=\"language-c\">void recopie(const char* entree, char* sortie)\n{\n    strcpy(sortie, entree);\n}\n\nint main()\n{\n    char donnee[] =\"abcdef\";\n    char resultat[strlen(donnee)+1];\n    recopie(donnee, resultat);\n    printf(\"%s %s\\n\", donnee, resultat);\n    return 0;\n}\n<\/code><\/pre>\n<p>Avant l&rsquo;appel de la fonction <code>recopie<\/code>, on cr\u00e9e un tableau de taille suffisante pour r\u00e9cup\u00e9rer le r\u00e9sultat.<\/p>\n<h5><a id=\"exercice-de-d%C3%A9couverte-d-dec-x9\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte D.dec.x9<\/h5>\n<p>Pourquoi la taille du tableau <code>resultat<\/code> est-elle fix\u00e9e \u00e0 <code>strlen(donnee+1)<\/code> et pas \u00e0 <code>strlen(donnee)<\/code> ?<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>Parce-que <code>strlen(donnee)<\/code> retourne le nombre de caract\u00e8res de la cha\u00eene <code>donnee<\/code> sanst comptabiliser le marqueur de fin. Or il faut pr\u00e9voir la place pour ce marqueur dans le chaine <code>resultat<\/code>.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<p>Voici un dessin qui montre la configuration en m\u00e9moire juste avant la fin de l&rsquo;ex\u00e9cution de la fonction <code>recopie<\/code>.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/01\/1-1.png\" alt=\"image-20211230104143581\" \/><\/p>\n<p>Il faut bien comprendre que les tableaux d&rsquo;entr\u00e9e et de sortie n&rsquo;existent qu&rsquo;en un seul exemplaires dans (l&rsquo;espace m\u00e9moire de) <code>main<\/code> et que ce sont seulement leurs adresses qui sont transmises \u00e0 <code>recopie<\/code>. Ceci n&rsquo;a rien de nouveau, c&rsquo;est la mani\u00e8re usuelle de proc\u00e9der avec des fonctions agissant sur des tableau, comme nous l&rsquo;avons vu dans la partie C.<\/p>\n<h5><a id=\"r%C3%A9aliser-le-traitement\" class=\"anchor\" aria-hidden=\"true\"><\/a>R\u00e9aliser le traitement<\/h5>\n<p>Notre objectif est de d\u00e9finir une fonction <code>filtre<\/code> qui supprime de la cha\u00eene tout autre caract\u00e8re que les lettres et chiffres. Mais comment savoir si un caract\u00e8re est une lettre, un chiffre ou autre chose ? Il existe des fonctions standards pour \u00e7a, mais c&rsquo;est tellement simple et instructif \u00e0 programmer que nous allons d\u00e9finir notre propre fonction.<\/p>\n<pre><code class=\"language-c\">int alphaNum(char c)\n{\n    if((c&gt;='a') &amp;&amp; (c&lt;='z')) return 1;\n    if((c&gt;='A') &amp;&amp; (c&lt;='Z')) return 1;\n    if((c&gt;='0') &amp;&amp; (c&lt;='9')) return 1;\n    return 0;\n}\n<\/code><\/pre>\n<p>On aurait pu utiliser une seule grosse condition avec des <code>||<\/code> et des <code>&amp;&amp;<\/code>, mais au d\u00e9triment de la lisibilit\u00e9.<\/p>\n<p>Voici maintenant la d\u00e9finition de la fonction qui est notre objectif depuis le d\u00e9but de cette section.<\/p>\n<pre><code class=\"language-c\">void filtre(const char* entree, char* sortie)\n{\n    int curseurSortie = 0;\n    int n = strlen(entree);\n    for(int i=0; i&lt;n; i++)\n    {\n        if(alphaNum(entree[i]))\n        {\n            sortie[curseurSortie] = entree[i];\n            curseurSortie++;\n        }\n    }\n    \/\/ Ne manquerait-il pas quelque chose ?\n}\n<\/code><\/pre>\n<p>Ici, nous sommes face \u00e0 un probl\u00e8me d&rsquo;algorithmique. Pour le r\u00e9soudre, j&rsquo;ai utilis\u00e9 une boucle <code>for<\/code> qui parcours un \u00e0 un tous les caract\u00e8res de la cha\u00eene d&rsquo;entr\u00e9e. Une variable appel\u00e9e <code>curseurSortie<\/code>, initialis\u00e9e \u00e0 0, indique la position o\u00f9 le prochain caract\u00e8re \u00e9ligible sera ajout\u00e9, si applicable, \u00e0 la cha\u00eene de sortie. Cette variable est incr\u00e9ment\u00e9e apr\u00e8s chaque ajout de caract\u00e8re \u00e0 la cha\u00eene de sortie.<\/p>\n<h5><a id=\"exercice-de-d%C3%A9couverte-d-dec-10\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte D.dec.10<\/h5>\n<p>Mais il manque quelque-chose pour garantir le bon fonctionnement de cette fonction. De quoi s&rsquo;agit-il et pourquoi ?<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>\u00c0 la place du commentaire \u00e0 la fin de la d\u00e9finition de la fonction <code>filtre<\/code>, il faut ajouter..<\/p>\n<pre><code class=\"language-c\">    sortie[curseurSortie] = 0;\n<\/code><\/pre>\n<p>&#8230;pour \u00eatre s\u00fbr que la cha\u00eene de sortie se termine bien par le marqueur de fin. en effet, le marqueur de fin de la cha\u00eene d&rsquo;entr\u00e9e n&rsquo;est pas recopi\u00e9 par la boucle.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<p>Vous avez maintenant toutes les cl\u00e9s pour r\u00e9aliser vos propres fonctions de traitement de cha\u00eenes de caract\u00e8res. Des exercices d&rsquo;entra\u00eenement vous permettrons de monter en comp\u00e9tence dans ce domaine. Mais auparavant, nous allons voir comment exploiter les arguments de la ligne de commande.<\/p>\n<h3><a id=\"d-dec4-exploitation-des-arguments-de-la-ligne-de-commande\" class=\"anchor\" aria-hidden=\"true\"><\/a>D.dec4 : Exploitation des arguments de la ligne de commande<\/h3>\n<h4><a id=\"pr%C3%A9requis\" class=\"anchor\" aria-hidden=\"true\"><\/a>Pr\u00e9requis<\/h4>\n<table>\n<thead>\n<tr>\n<th>Avoir bien compris les notions et techniques pr\u00e9sent\u00e9e dans les sections D.dec1 et D.dec2<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<h4><a id=\"objectif\" class=\"anchor\" aria-hidden=\"true\"><\/a>Objectif<\/h4>\n<table>\n<thead>\n<tr>\n<th>R\u00e9aliser un programme exploitant des arguments pass\u00e9s en ligne de commande<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Jusqu&rsquo;\u00e0 maintenant, nos programmes ne prenaient pas en compte des donn\u00e9es fournies au clavier par la personne utilisatrice. L&rsquo;un des moyens de prendre en compte de telles donn\u00e9es est de demander \u00e0 la personne utilisatrice de les saisir au moment de l&rsquo;appel du programme. Prenons l&rsquo;exemple d&rsquo;un programme permettant de calculer rapidement la moyenne de quelques nombres.<\/p>\n<p>Depuis la console, il s&rsquo;utilise en tapant la nom du programme, <code>moyenne<\/code>, suivi des valeurs dont on veut la moyenne, s\u00e9par\u00e9es par des espaces. Voici un exemple :<\/p>\n<pre><code class=\"language-plain_text\">&gt; moyenne 12.5 10.0 8.5\n<\/code><\/pre>\n<p>Le programme doit alors afficher le r\u00e9sultat dans la console :<\/p>\n<pre><code class=\"language-plain_text\">&gt; 10.33\n<\/code><\/pre>\n<p>Pour permettre cela, notre programme doit r\u00e9cup\u00e9rer les <strong>arguments de la ligne de commande<\/strong>, c&rsquo;est \u00e0 dire les donn\u00e9es qui suivent le nom du programme ex\u00e9cutable et sont s\u00e9par\u00e9es par des espaces.<\/p>\n<h4><a id=\"moyen\" class=\"anchor\" aria-hidden=\"true\"><\/a>Moyen<\/h4>\n<table>\n<thead>\n<tr>\n<th>Exploiter les param\u00e8tres de la fonction main<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Jusqu&rsquo;\u00e0 maintenant, dans tous nos exemples, la fonction <code>main<\/code> n&rsquo;avait pas de param\u00e8tres. Mais on peut utiliser une variante de <code>main<\/code> avec param\u00e8tres, comme dans l&rsquo;exemple ci-dessous.<\/p>\n<pre><code class=\"language-c\">int main(int argc, char *argv[])\n{\n    printf(\"Arguments de la ligne de commande :\\n\");\n    for(int i=0; i&lt;argc; i++)\n    {\n        printf(\"%s\\n\", argv[i]);\n    }\n    return 0;\n}\n<\/code><\/pre>\n<p>On compile le programme en donnant le nom <code>progtest<\/code> \u00e0 l&rsquo;ex\u00e9cutable et on le lance avec la ligne de commande suivante :<\/p>\n<pre><code class=\"language-plain_text\">&gt; progTest 12.5 10.0 8.5\n<\/code><\/pre>\n<p>L&rsquo;affichage produit est :<\/p>\n<pre><code class=\"language-plain_text\">.\/progtest\n12.5\n10.0\n8.5\n<\/code><\/pre>\n<p>Voici les cl\u00e9s pour expliquer ce r\u00e9sultat.<\/p>\n<ol>\n<li>La valeur de <code>argc<\/code> est \u00e9gale au <strong>nombre d&rsquo;arguments pass\u00e9s en ligne de commande plus 1<\/strong>. Dans l&rsquo;exemple d&rsquo;appel ci-dessus, il vaut 4.<\/li>\n<li><code>argv<\/code> d\u00e9signe un tableau de pointeurs de type <code>char*<\/code> d\u00e9signant des cha\u00eenes de caract\u00e8res. <code>argv[0]<\/code> d\u00e9signe une cha\u00eene contenant le nom du programme, <code>argv[1]<\/code> d\u00e9signe une cha\u00eene de caract\u00e8re contenant le premier argument pass\u00e9 en ligne de commande, <code>argv[2]<\/code> le deuxi\u00e8me argument, etc.<\/li>\n<\/ol>\n<p>C&rsquo;est donc sous la forme de <strong>cha\u00eenes de caract\u00e8res<\/strong> que nous r\u00e9cup\u00e9rons les arguments de la ligne de commande, <em>m\u00eame si ceux-ci ont l&rsquo;apparence de nombres<\/em>.<\/p>\n<p>Pour notre application de calcul de moyenne, il va nous falloir transformer en valeurs de type <code>double<\/code> des donn\u00e9es qui se pr\u00e9sentent sous la forme de cha\u00eenes de caract\u00e8res. Heureusement, il existe des fonctions toutes faites pour faire cela. Examinons le code du programme propos\u00e9. Attention, il faut inclure les fichiers d&rsquo;ent\u00eate <code>string.h<\/code>, <code>stdlib.h<\/code> et <code>stdio.h<\/code> pour le compiler.<\/p>\n<pre><code class=\"language-c\">int main(int argc, char *argv[])                \/\/ Ligne A\n{\n    double sum = 0.0;\n    for(int i=1; i&lt;argc; i++)\n    {\n        double valeur = 0.0;                    \/\/ Ligne B\n        sscanf(argv[i], \"%lf\", &amp;valeur);        \/\/ Ligne C\n        sum = sum + valeur;\n    }\n    printf(\"Moyenne : %.02lf\", sum \/ (argc-1));  \/\/ Ligne D\n    return 0;\n}\n<\/code><\/pre>\n<p><strong>En ligne A<\/strong>, on d\u00e9finit la m\u00e9thode <code>main<\/code> dans sa version permettant de r\u00e9cup\u00e9rer les arguments de la ligne de commande.<\/p>\n<p><strong>En ligne B<\/strong>, on d\u00e9clare une variable destin\u00e9e \u00e0 recevoir la valeur de type <code>double<\/code> repr\u00e9sent\u00e9e par un des arguments de la ligne de commande.<\/p>\n<p><strong>En ligne C<\/strong>, on utilise la tr\u00e8s puissante fonction standard <code>sscanf<\/code> pour convertir en <code>double<\/code> la cha\u00eene de caract\u00e8res <code>argv[i]<\/code>, c&rsquo;est \u00e0 dire l&rsquo;argument apparaissant en position <code>i<\/code> dans la ligne de commande. Cette fonction lit une donn\u00e9e dans une cha\u00eene de caract\u00e8res et la convertit, si applicable, dans le format indiqu\u00e9 en deuxi\u00e8me param\u00e8tre, ici <code>\"%lf\"<\/code> pour le format <code>double<\/code>. Le r\u00e9sultat est plac\u00e9 dans la variable dont l&rsquo;adresse est donn\u00e9e par le troisi\u00e8me param\u00e8tre de <code>scanf<\/code>.<\/p>\n<p><strong>En ligne D<\/strong>, la somme des valeurs pass\u00e9es via les arguments de la ligne de commande est divis\u00e9e par le nombre d&rsquo;arguments pour obtenir la moyenne, qui est affich\u00e9e au format <code>%.02lf<\/code>, c&rsquo;est \u00e0 dire avec 2 chiffres apr\u00e8s le point d\u00e9cimal.<\/p>\n<h5><a id=\"exercice-de-d%C3%A9couverte-d-dec-x11\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte D.dec.x11<\/h5>\n<p>Modifiez la fonction <code>main<\/code> de l&rsquo;exemple pour qu&rsquo;elle ne r\u00e9alise aucun calcul et affiche le message \u00ab\u00a0aucun argument\u00a0\u00bb si aucun argument n&rsquo;est pass\u00e9 \u00e0 la ligne de commande.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\">int main(int argc, char *argv[])\n{\n    if(argc==1)\n    {\n        printf(\"Aucun argument\\n\");\n    }\n    else\n    {\n        double sum = 0.0;\n        for(int i=1; i&lt;argc; i++)\n        {\n            double valeur;\n            sscanf(argv[i], \"%lf\", &amp;valeur);\n            sum = sum + valeur;\n        }\n        printf(\"Moyenne : %.02lf\", sum \/ (argc-1));\n    }\n    return 0;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h4><a id=\"bonus\" class=\"anchor\" aria-hidden=\"true\"><\/a>Bonus<\/h4>\n<table>\n<thead>\n<tr>\n<th>Saisie au clavier, compl\u00e9ments sur les flottants.<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<h5><a id=\"les-types-flottants\" class=\"anchor\" aria-hidden=\"true\"><\/a>Les types flottants<\/h5>\n<p>Un petit hors sujet dans cette partie sur les cha\u00eenes. Jusqu&rsquo;\u00e0 maintenant nous avons toujours utilis\u00e9 le type <code>double<\/code> pour repr\u00e9senter des nombres flottants. Mais il existe deux autres types nomm\u00e9s <code>float<\/code> et <code>long double<\/code>. Le premier occupe deux fois moins de m\u00e9moire que <code>double<\/code>, mais couvre une plage de valeurs plus faible et offre une pr\u00e9cision moindre (6 d\u00e9cimales au lieu de 15). Le type <code>long double<\/code> offre une plus grande pr\u00e9cision que <code>double<\/code> et occupe plus de place en m\u00e9moire. L&rsquo;\u00e9tude des ces types ne fait pas partie des objectifs du pr\u00e9sent enseignement. Ils sont mentionn\u00e9s ici pour information. Dans la suite, comme nous l&rsquo;avons fait jusqu&rsquo;ici, nous utiliserons uniquement le type <code>double<\/code>.<\/p>\n<p>Dans les cha\u00eenes de formatage des fonctions <code>printf<\/code> et <code>sscanf<\/code>, le format <code>%f<\/code> signifie <code>float<\/code> alors que <code>%lf<\/code> signifie <code>double<\/code>. Mais <code>printf<\/code> ne fait pas de diff\u00e9rence entre <code>%f<\/code> et <code>%lf<\/code> et convertit en <code>double<\/code> toute valeur de type <code>float<\/code> qui lui est pass\u00e9e en argument. En revanche, <code>sscanf<\/code> fait la distinction.<\/p>\n<h5><a id=\"les-fonctions-scanf-et-sscanf\" class=\"anchor\" aria-hidden=\"true\"><\/a>Les fonctions scanf et sscanf<\/h5>\n<p>Nous avons utilis\u00e9 plus haut la fonction <code>sscanf<\/code>. Il existe une fonction similaire nomm\u00e9e <code>scanf<\/code> qui lit des donn\u00e9es au clavier. Ces fonctions peuvent lire plusieurs valeurs en un seul appel, mais nous allons seulement voir leur utilisation pour lire une valeur.<\/p>\n<p>La fonction&#8230;<\/p>\n<pre><code class=\"language-c\">int scanf( const char *format, void* destination );\n<\/code><\/pre>\n<p>&#8230; lit une valeur saisie au clavier. Le format de cette valeur est donn\u00e9 par le param\u00e8tre <code>format<\/code>. Pour lire un entier d\u00e9cimal on utilise le format <code>\"%d\"<\/code>, pour lire un entier repr\u00e9sent\u00e9 en hexad\u00e9cimal on utilise le format <code>\"%x\"<\/code>, pour lire une valeur de type <code>double<\/code>, le format <code>%lf<\/code>, etc. Le r\u00e9sultat de la lecture est plac\u00e9 dans la variable point\u00e9e par <code>destination<\/code>.<\/p>\n<p>La valeur de retour est 1 si une valeur est lue, 0 sinon.<\/p>\n<p>Voici un exemple d&rsquo;utilisation.<\/p>\n<pre><code class=\"language-c\">int main(int argc, char *argv[])\n{\n    int valeur = 0;\n    scanf(\"%d\", &amp;valeur);\n    printf(\"Valeur lue : %d\\n\", valeur);\n}\n<\/code><\/pre>\n<p>\u00c0 l&rsquo;ex\u00e9cution si on saisit <code>102<\/code> et <code>entr\u00e9e<\/code>, le programme affiche :<\/p>\n<pre><code class=\"language-plain_text\">Valeur de retour : 1, Valeur lue : 102\n<\/code><\/pre>\n<p>Si on saisit <code>17abc<\/code> et <code>entr\u00e9e<\/code>, le programme affiche :<\/p>\n<pre><code class=\"language-plain_text\">Valeur de retour : 1, Valeur lue : 17\n<\/code><\/pre>\n<p>Les caract\u00e8res saisis sont convertis tant qu&rsquo;ils sont en coh\u00e9rence avec le type de valeur \u00e0 saisir.<\/p>\n<p>Si on saisit <code>abc54<\/code> puis <code>entr\u00e9e<\/code>, le programme affiche :<\/p>\n<pre><code class=\"language-plain_text\">Valeur de retour : 0, Valeur lue : 0\n<\/code><\/pre>\n<p>La valeur de retour \u00e9tant 0, aucune valeur n&rsquo;est \u00e9crite dans la variable <code>valeur<\/code>, qui conserve sa valeur d&rsquo;initialisation.<\/p>\n<p>Le format de saisie <code>%s<\/code> est autoris\u00e9 mais <strong>fortement d\u00e9conseill\u00e9e<\/strong> car on ne peut pas emp\u00eacher un d\u00e9bordement du tableau de destination et la saisie s&rsquo;arr\u00eate non seulement si la touche entr\u00e9e est tap\u00e9e, mais aussi si la touche espace est tap\u00e9e. Pour saisir une cha\u00eene au clavier, il est conseill\u00e9 d&rsquo;utiliser la fonction standard <code>fgets<\/code>.<\/p>\n<p>La fonction&#8230;<\/p>\n<pre><code class=\"language-c\">int sscanf( const char * buffer, const char *format, void* destination );\n<\/code><\/pre>\n<p>&#8230;se comporte comme <code>scanf<\/code> saut qu&rsquo;au lieu de lire la donn\u00e9e \u00e0 saisir au clavier, elle la lit dans la cha\u00eene de caract\u00e8re d\u00e9sign\u00e9e par <code>buffer<\/code>.<\/p>\n<h5><a id=\"la-fonction-fgets\" class=\"anchor\" aria-hidden=\"true\"><\/a>La fonction fgets<\/h5>\n<pre><code class=\"language-c\">char * fgets( char * dest, int maxLength, FILE * stream );\n<\/code><\/pre>\n<p>Elle permet de lire une cha\u00eene de caract\u00e8res dans un fichier, ce qui est hors du scope de cet enseignement, mais peut \u00eatre utilis\u00e9e pour saisir une cha\u00eene au clavier si la constante pr\u00e9d\u00e9finie <code>stdin<\/code> est utilis\u00e9e comme troisi\u00e8me argument. Le param\u00e8tre <code>dest<\/code> d\u00e9signe le tableau dans lequel la cha\u00eene saisie doit \u00eatre plac\u00e9e. Le nombre maximum de caract\u00e8res saisi est \u00e9gal \u00e0 <code>maxLenght-1<\/code>. Il est imp\u00e9ratif qu&rsquo;\u00e0 l&rsquo;appel, la valeur de <code>MaxLength<\/code> soit inf\u00e9rieure ou \u00e9gale \u00e0 la taille du tableau de destination d\u00e9sign\u00e9 par <code>dest<\/code>. Voici un exemple d&rsquo;utilisation.<\/p>\n<pre><code class=\"language-c\">int main(int argc, char *argv[])\n{\n    char buffer[10];\n    fgets(buffer, 10, stdin);\n    printf(\"Chaine saisie : %s\", buffer);\n}\n<\/code><\/pre>\n<p>Si on saisi la cha\u00eene&#8230;<\/p>\n<pre><code class=\"language-plain_text\">Bonjour, comment allez-vous ?\n<\/code><\/pre>\n<p>&#8230; Le programme affiche :<\/p>\n<pre><code class=\"language-plain_text\">Chaine saisie : Bonjour, \n<\/code><\/pre>\n<p>La saisie a \u00e9t\u00e9 tronqu\u00e9e \u00e0 9 caract\u00e8res. Le marqueur de fin est ajout\u00e9 automatiquement.<\/p>\n<hr \/>\n<p>L&rsquo;activit\u00e9 est termin\u00e9e. Vous devez \u00e9valuer votre r\u00e9ussite de cette activit\u00e9 par une valeur entre 1 et 4.<\/p>\n<ol>\n<li>Vous n&rsquo;avez presque rien compris et \u00e9chou\u00e9 \u00e0 plus de la moiti\u00e9 des exercices de d\u00e9couverte.<\/li>\n<li>Vous estimez avoir compris une partie des explications et vous avez r\u00e9ussi au moins la moiti\u00e9 des exercices de d\u00e9couverte, mais certaines notions sont encore floues.<\/li>\n<li>Vous estimez avoir bien compris les explications et vous avez r\u00e9ussi presque tous les exercices de d\u00e9couverte, mais certaines notions abord\u00e9es \u00e9taient nouvelles et vous penser avoir besoin d&rsquo;un entrainement pour bien les assimiler et \u00eatre en mesure de les utiliser en pratique.<\/li>\n<li>Vous connaissiez d\u00e9j\u00e0 tout ce qui a \u00e9t\u00e9 pr\u00e9sent\u00e9 (sauf peut \u00eatre quelques d\u00e9tails) et il ne sera pas n\u00e9cessaire que vous reveniez sur ces notions.<\/li>\n<\/ol>\n<p>Si votre score est 1 ou 2, vous devrez refaire cette activit\u00e9 rapidement, <strong>mais apr\u00e8s au moins une nuit de sommeil<\/strong>, avant de passer aux activit\u00e9s suivantes. Si votre score est 3 ou 4, vous devez faire les activit\u00e9s suivantes et il ne sera pas n\u00e9cessaire de revenir sur cette activit\u00e9, \u00e0 part pour rechercher des informations utiles pour d&rsquo;autres activit\u00e9s.<\/p>\n<hr \/>\n<h2><a id=\"activit%C3%A9-d-entra%C3%AEnement-d-ent\" class=\"anchor\" aria-hidden=\"true\"><\/a>Activit\u00e9 d&rsquo;entra\u00eenement D.ent<\/h2>\n<p>Cette activit\u00e9 est essentielle. C&rsquo;est gr\u00e2ce \u00e0 elle que vous apprendrez vraiment \u00e0 comprendre et utiliser les notions vues pr\u00e9c\u00e9demment. Elle se d\u00e9compose en plusieurs <strong>it\u00e9rations<\/strong> : <strong>ent1<\/strong>, <strong>ent2<\/strong>, etc.<\/p>\n<p>Vous devez r\u00e9aliser au moins une it\u00e9ration et \u00e9valuer votre niveau de r\u00e9ussite par une valeur entre 1 et 4 selon les crit\u00e8res habituels. L&rsquo;it\u00e9ration que vous avez trait\u00e9 le plus r\u00e9cemment est appel\u00e9e <strong>it\u00e9ration courante<\/strong>. On appelle <strong>it\u00e9ration suivante<\/strong> celle qui suit l&rsquo;it\u00e9ration courante, except\u00e9 si l&rsquo;it\u00e9ration courante est la derni\u00e8re disponible, auquel cas l&rsquo;it\u00e9ration suivante est la premi\u00e8re it\u00e9ration.<\/p>\n<p><strong>Si le r\u00e9sultat est 1<\/strong>, vous devrez traiter \u00e0 nouveau l&rsquo;activit\u00e9 de d\u00e9couverte pr\u00e9c\u00e9dente, en laissant passer au moins une nuit, avant de revenir \u00e0 cette activit\u00e9 d&rsquo;entra\u00eenement en r\u00e9alisant \u00e0 nouveau l&rsquo;it\u00e9ration courante. Vous devez aussi essayer d&rsquo;identifier les points de blocage et demander \u00e0 votre enseignant de vous aider \u00e0 les surmonter.<\/p>\n<p><strong>Si le r\u00e9sultat est 2<\/strong>, vous devrez d&rsquo;abord comprendre ce qui vous a conduit \u00e0 des erreurs et \/ ou ce qui vous a bloqu\u00e9. Si vous avez des doutes, des difficult\u00e9s, essayez de trouver les r\u00e9ponses dans les pr\u00e9sentations et explication de l&rsquo;activit\u00e9 de d\u00e9couverte pr\u00e9c\u00e9dente et demandez toute l&rsquo;aide n\u00e9cessaire \u00e0 votre enseignant. Ensuite, vous devrez r\u00e9aliser l&rsquo;it\u00e9ration suivante de l&rsquo;activit\u00e9 d&rsquo;entra\u00eenement actuelle apr\u00e8s un d\u00e9lai d&rsquo;au moins deux jours et d&rsquo;au plus une semaine.<\/p>\n<p><strong>Si le r\u00e9sultat est 3<\/strong>, vous devrez revenir traiter l&rsquo;it\u00e9ration suivante apr\u00e8s un d\u00e9lai de plusieurs semaines.<\/p>\n<p>En traitant les exercices, vous devrez consid\u00e9rer que les param\u00e8tres des fonctions ont des valeurs correctes. Il ne vous est pas demand\u00e9 de v\u00e9rifier si certaines valeurs sont aberrantes au regard de ce que demande l&rsquo;\u00e9nonc\u00e9. Par exemple, si un param\u00e8tre doit \u00eatre positif pour que le traitement demand\u00e9 soit possible, vous consid\u00e9rerez que la fonction sera appel\u00e9e avec une valeur positive de ce param\u00e8tre.<\/p>\n<p><strong>Vous pouvez utiliser un ordinateur<\/strong> pour tester vos solutions et les corriger en cas de comportement inattendu. C&rsquo;est m\u00eame <strong>recommand\u00e9<\/strong>, <strong>\u00e0 condition de commencer par r\u00e9fl\u00e9chir avant de vous jeter sur le clavier<\/strong>. Si vous pensez avoir une solution diff\u00e9rente de celle propos\u00e9e, ce qui peut arriver souvent, vous ne devez en aucun cas rester dans le doute. Vous <strong>devez<\/strong> v\u00e9rifier si votre solution est correcte ou non, soit en testant votre solution avec un ordinateur, soit en demandant \u00e0 une personne enseignante.<\/p>\n<h3><a id=\"it%C3%A9ration-d-ent1\" class=\"anchor\" aria-hidden=\"true\"><\/a>It\u00e9ration D.ent1<\/h3>\n<h4><a id=\"exercice-d-entrainement-d-ent1-1\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement D.ent1.1<\/h4>\n<p><strong>Question 1.<\/strong> Sans utiliser de compilateur, donnez les affichages r\u00e9alis\u00e9s par l&rsquo;ex\u00e9cution des lignes de code suivantes.<\/p>\n<pre><code class=\"language-c\">    char s1[20] = \"aaaaaa\";\n    strcat(s1+2,\"bbb\");\n    printf(\"%s\\n\", s1);          \n<\/code><\/pre>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>Il faut dessiner les tableaux contenant les cha\u00eenes pour bien comprendre les effets des op\u00e9rations r\u00e9alis\u00e9es.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/01\/2-1.png\" alt=\"image-20211231193411413\" \/><\/p>\n<p>La cha\u00eene <code>\"bbb\"<\/code> sera ajout\u00e9e \u00e0 la <strong>fin<\/strong> de la cha\u00eene commen\u00e7ant en <code>s1+2<\/code>. En effet, <code>strcat<\/code> r\u00e9alise une concat\u00e9nation et pas une simple copie.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-plain_text\">aaaaaabbb\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<p><strong>Question 2.<\/strong> M\u00eame question avec les lignes suivantes.<\/p>\n<pre><code class=\"language-c\">    char s2[20] = \"aaaaaa\";\n    strcpy(s2+2, \"bbbbbb\");\n    printf(\"%s\\n\", s2);  \n<\/code><\/pre>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>La fonction <code>strcpy<\/code> va \u00e9craser la partie de la cha\u00eene initiale commen\u00e7ant \u00e0 l&rsquo;adresse <code>s+2<\/code>.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-plain_text\">aabbbbbb\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<p><strong>Question 3.<\/strong> M\u00eame question avec les lignes suivantes.<\/p>\n<pre><code class=\"language-c\">    char s3[20] = \"abcdef\";\n    s3[3] = 0;\n    printf(\"%s %s\\n\", s3, s3+5); \n<\/code><\/pre>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>Dans une telle situation, il est extr\u00eamement conseill\u00e9 de faire un dessin.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/01\/3-1.png\" alt=\"image-20211231200852446\" \/><\/p>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-plain_text\">abc f\n<\/code><\/pre>\n<p>Il faut comprendre que la cha\u00eene d\u00e9sign\u00e9e par <code>s3+5<\/code> est juste constitu\u00e9e du caract\u00e8re <code>'f'<\/code>.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<p><strong>Question 4.<\/strong> M\u00eame question avec les lignes suivantes.<\/p>\n<pre><code class=\"language-c\">    char s4[20] = \"abcdef\";\n    int n1 = strlen(s4);\n    int n2 = strlen(s4+1);\n    s4[n1] = '9';\n    s4[n2] = 0;\n    printf(\"%s\\n\", s4);\n<\/code><\/pre>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>Ici encore, il faut faire un dessin des modifications r\u00e9alis\u00e9es par les deux lignes pr\u00e9c\u00e9dent l&rsquo;appel \u00e0 <code>printf<\/code> apr\u00e8s avoir d\u00e9termin\u00e9 que <code>n1<\/code> vaut 6 et que <code>n2<\/code>, c&rsquo;est \u00e0 dire la longueur de la cha\u00eene <code>\"bcdef\"<\/code>, vaut 5.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/01\/4-1.png\" alt=\"image-20211231192446243\" \/><\/p>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-plain_text\">abcde\n<\/code><\/pre>\n<p>Le caract\u00e8re <code>'9'<\/code> se retrouve au del\u00e0 du marqueur de fin de cha\u00eene et n&rsquo;est donc pas affich\u00e9.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h4><a id=\"exercice-d-entrainement-d-ent1-2\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement D.ent1.2<\/h4>\n<p>Vous devez impl\u00e9menter une fonction&#8230;<\/p>\n<pre><code class=\"language-c\">void toutMaj(char* str)\n<\/code><\/pre>\n<p>&#8230;qui remplace toutes les lettre minuscules de la cha\u00eene d\u00e9sign\u00e9e par <code>str<\/code> par les lettre majuscules correspondantes. Toutes les occurrences de <code>'a'<\/code> sont remplac\u00e9es par <code>'A'<\/code>, les occurrences de <code>'b'<\/code> sont remplac\u00e9es par <code>'B'<\/code>, etc. Les autres caract\u00e8res ne sont pas affect\u00e9s.<\/p>\n<p>Pour v\u00e9rifier que vous avez parfaitement compris ce qui est demand\u00e9, donnez le code d&rsquo;une fonction <code>main<\/code> qui place dans un tableau la cha\u00eene <code>\"abc 12 Def\"<\/code> et appelle la fonction <code>toutMaj<\/code> pour transformer cette cha\u00eene en <code>\"ABC 12 DEF\"<\/code> et afficher cette cha\u00eene.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\">int main()\n{\n    char s[] = \"abc 12 Def\";\n\t  toutMaj(s);\n    printf(\"%s\\n\", s);\n    return 0;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<p>\u00c0 pr\u00e9sent vous pouvez r\u00e9aliser la fonction <code>toutMaj<\/code>. Vous ne devez pas utiliser ni consulter de table de code <code>ASCII<\/code>. Vous n&rsquo;en avez pas besoin car le langage C connait d\u00e9j\u00e0 ces codes. Si, par exemple, vous avez besoin du code <code>ASCII<\/code> de la lettre A, il suffit d&rsquo;\u00e9crire <code>'A'<\/code> et le compilateur consid\u00e9rera que cette notation <strong>est<\/strong> le code <code>ASCII<\/code> de A.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>Il faut parcourir la cha\u00eene initiale, identifier les lettres minuscules et les remplacer par les majuscules correspondantes. Pour d\u00e9terminer si un caract\u00e8re repr\u00e9sente une lettre minuscule, il suffi de v\u00e9rifier s&rsquo;il est sup\u00e9rieur ou \u00e9gal \u00e0 <code>'a'<\/code> et inf\u00e9rieur ou \u00e9gal \u00e0 <code>'z'<\/code>. On peut comparer les caract\u00e8res comme des entiers puisque ce <strong>sont<\/strong> des entiers.<\/p>\n<p>Pour obtenir la lettre majuscule correspondant \u00e0 une lettre minuscule situ\u00e9e dans une variable <code>c<\/code>, il faut ajouter \u00e0 <code>c<\/code> une valeur, que nous pouvons appeler <code>delta<\/code>, repr\u00e9sentant la distance, dans le code <code>ASCII<\/code>, entre les lettres majuscules et les lettres minuscules. Essayez de trouver un moyen simple de calculer cette valeur <code>delta<\/code>.<\/p>\n<pre><code class=\"language-c\">void toutMaj(char* str)\n{\n    int n = strlen(str);\n    int delta = \/\/ \u00c0 compl\u00e9ter\n    for(int i=0; i&lt;n; i++)\n    {\n        \/\/ \u00c0 compl\u00e9ter\n    }\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice2<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>Par d\u00e9finition, <code>'a' + delta<\/code> vaut <code>'A'<\/code> puisque <code>delta<\/code> est la valeur \u00e0 ajouter \u00e0 toute lettre minuscule pour obtenir la lettre majuscule correspondante. Donc <code>delta<\/code> vaut <code>'A' - 'a'<\/code>. \u00c9videmment, cette valeur est aussi \u00e9gale \u00e0 <code>'B' - 'b'<\/code>, <code>'C' - 'c'<\/code>, etc.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Solution<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\">void toutMaj(char* str)\n{\n    int n = strlen(str);\n    int delta = 'A' - 'a';\n    for(int i=0; i&lt;n; i++)\n    {\n        if((str[i]&gt;='a') &amp;&amp; (str[i]&lt;='z'))\n        {\n            str[i] = str[i] + delta;\n        }\n    }\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h4><a id=\"exercice-d-entrainement-d-ent1-3\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement D.ent1.3<\/h4>\n<p>Vous devez impl\u00e9menter une fonction&#8230;<\/p>\n<pre><code class=\"language-c\">void randomStr(const char* cars, char* dest, int n)\n<\/code><\/pre>\n<p>&#8230;qui produit une cha\u00eene al\u00e9atoire constitu\u00e9e de <code>n<\/code> caract\u00e8res tir\u00e9s au hasard parmi les caract\u00e8res situ\u00e9s dans la cha\u00eene d\u00e9sign\u00e9e par <code>cars<\/code>. Le r\u00e9sultat est plac\u00e9 dans le tableau d\u00e9sign\u00e9 par <code>dest<\/code>, qui est suppos\u00e9 avoir une taille au moins \u00e9gale \u00e0 <code>n+1<\/code>.<\/p>\n<p>Pour v\u00e9rifier que vous avez parfaitement compris ce qui vous est demand\u00e9, donnez le code d&rsquo;une fonction <code>main<\/code> qui utilise la fonction <code>randStr<\/code> pour produire et afficher une cha\u00eene al\u00e9atoire constitu\u00e9e uniquement de 6 lettres majuscules.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\">int main()\n{\n    srand(time(NULL));\n    char cars[] = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\";\n    char dest[7];\n    randomStr(cars, dest, 6);\n    printf(\"%s\\n\", dest);\n    return 0;\n}\n<\/code><\/pre>\n<p>Le tableau de destination a une taille \u00e9gale \u00e0 7 pour recevoir les 6 caract\u00e8res de la cha\u00eene \u00e0 produire plus le marqueur de fin.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\">void randomStr(const char* cars, char* dest, int n)\n{\n    int nCars = strlen(cars);\n    for(int i=0; i&lt;n; i++)\n    {\n        \/\/ \u00c0 compl\u00e9ter\n    }\n    \/\/ \u00c0 compl\u00e9ter\n}\n<\/code><\/pre>\n<p>La production d&rsquo;une caract\u00e8re al\u00e9atoire peut se faire en lisant une valeur du tableau d\u00e9sign\u00e9 par <code>cars<\/code> \u00e0 un indice tir\u00e9 al\u00e9atoirement entre 0 et <code>nCars-1<\/code>.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Solution<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\">void randomStr(const char* cars, char* dest, int n)\n{\n    int nCars = strlen(cars);\n    for(int i=0; i&lt;n; i++)\n    {\n        dest[i] = cars[rand()%nCars];\n    }\n    dest[n] = 0;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h3><a id=\"it%C3%A9ration-d-ent2\" class=\"anchor\" aria-hidden=\"true\"><\/a>It\u00e9ration D.ent2<\/h3>\n<h4><a id=\"exercice-d-entrainement-d-ent2-1\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement D.ent2.1<\/h4>\n<p><strong>Question 1.<\/strong> Sans utiliser de compilateur, donnez les affichages r\u00e9alis\u00e9s par l&rsquo;ex\u00e9cution des lignes de code suivantes.<\/p>\n<pre><code class=\"language-c\">    char s1[20] = \"aaaaaa\";\n    strcpy(s1+3,\"bbb\");\n    printf(\"%s\\n\", s1);          \n<\/code><\/pre>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>Faites un dessin pour bien localiser l&#8217;emplacement \u00e0 partir duquel la cha\u00eene <code>\"bbb\"<\/code> et son marqueur de fin sont recopi\u00e9s par l&rsquo;appel de <code>strcpy<\/code>.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-plain_text\">aaabbb\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<p><strong>Question 2.<\/strong> M\u00eame question avec les lignes suivantes.<\/p>\n<pre><code class=\"language-c\">    char s2[20] = \"aaaaaa\";\n    strcpy(s2+strlen(s2), \"bbb\");\n    printf(\"%s\\n\", s2);  \n<\/code><\/pre>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>La fonction <code>strcpy<\/code> va copier la cha\u00eene <code>\"bbb\"<\/code> juste apr\u00e8s le dernier caract\u00e8re de la cha\u00eene <code>\"aaaaaa\"<\/code>.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-plain_text\">aaaaaabbb\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<p><strong>Question 3.<\/strong> M\u00eame question avec les lignes suivantes.<\/p>\n<pre><code class=\"language-c\">    char s3[20] = \"abcdef\";\n    char r3[20];\n    strcpy(r3,s3+3);\n    printf(\"%s\\n\", r3);\n<\/code><\/pre>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>La partie de la cha\u00eene situ\u00e9e dans le tableau d\u00e9sign\u00e9 par <code>s3<\/code> commen\u00e7ant en position 3 (donc \u00e0 partir du quatri\u00e8me caract\u00e8re puisque le premier est en position 0) sera copi\u00e9e dans le tableau d\u00e9sign\u00e9 par <code>r3<\/code>.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-plain_text\">def\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<p><strong>Question 4.<\/strong> M\u00eame question avec les lignes suivantes.<\/p>\n<pre><code class=\"language-c\">    char s4[20] = \"abcdef\";\n    strcpy(s4+2,\"xy\");\n    s4[4] = 'z';\n    printf(\"%s\\n\", s4);\n<\/code><\/pre>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>Il est difficile de visualiser mentalement ce qui ce passe en m\u00e9moire. Dans une telle situation il est fortement conseill\u00e9 de faire un dessin pour localiser pr\u00e9cis\u00e9ment les cellules du tableau qui seront impact\u00e9es par les deuxi\u00e8me et troisi\u00e8me lignes de code.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/01\/5-1.png\" alt=\"image-20211231200640341\" \/><\/p>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-plain_text\">abxyzf\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h4><a id=\"exercice-d-entrainement-d-ent2-2\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement D.ent2.2<\/h4>\n<p>Vous devez impl\u00e9menter une fonction&#8230;<\/p>\n<pre><code class=\"language-c\">void extract(const char* entree, char balise, char* sortie)\n<\/code><\/pre>\n<p>&#8230;permettant d&rsquo;extraire la partie de la cha\u00eene d&rsquo;entr\u00e9e situ\u00e9 entre deux caract\u00e8res <code>balise<\/code>. La cha\u00eene extraite doit \u00eatre plac\u00e9e dans le tableau d\u00e9sign\u00e9 par le param\u00e8tre <code>sortie<\/code>. On suppose que le tableau de sortie a une taille suffisante pour recevoir le r\u00e9sultat, incluant le marqueur de fin de cha\u00eene.<\/p>\n<p>Si le caract\u00e8re <code>balise<\/code> n&rsquo;apparait pas dans la cha\u00eene d&rsquo;entr\u00e9e, la cha\u00eene vide doit \u00eatre plac\u00e9e dans le tableau de sortie. Si le caract\u00e8re <code>balise<\/code> apparait une seule fois, tout ce qui est situ\u00e9 apr\u00e8s la balise doit \u00eatre plac\u00e9 dans le tableau de sortie. Si le caract\u00e8re <code>balise<\/code> appara\u00eet plus de deux fois, tout ce qui suit la deuxi\u00e8me occurrence doit \u00eatre ignor\u00e9.<\/p>\n<p>Voici un exemple de fonction <code>main<\/code> qui appelle la fonction <code>extract<\/code> pour extraire la sous-cha\u00eene situ\u00e9e entre deux caract\u00e8res <code>#<\/code> dans la cha\u00eene <code>\"abcd 12#xyz12#123\"<\/code>.<\/p>\n<pre><code class=\"language-c\">int main()\n{\n    char entree[] = \"abcd 12#xyz12#123\";\n    char sortie[strlen(entree)+1];\n    extract(entree, '#', sortie);\n    printf(\"%s\\n\", sortie);\n    return 0;\n}\n<\/code><\/pre>\n<p>L&rsquo;ex\u00e9cution produit l&rsquo;affichage suivant :<\/p>\n<pre><code class=\"language-plain_text\">xyz12\n<\/code><\/pre>\n<p>Le traitement r\u00e9alis\u00e9 par la fonction <code>extract<\/code> doit \u00eatre d\u00e9compos\u00e9 en trois phases num\u00e9rot\u00e9es 1, 2 et 3.<\/p>\n<ul>\n<li>La phase 1 dure jusqu&rsquo;\u00e0 la lecture de la premi\u00e8re occurence de la balise.<\/li>\n<li>La phase 2 commence apr\u00e8s le lecture de la premi\u00e8re occurrence de la balise et se termine au moment de la lecture de la deuxi\u00e8me occurrence de la balise.<\/li>\n<li>La phase 3 succ\u00e8de \u00e0 la phase 2 et termine l&rsquo;ex\u00e9cution de la fonction apr\u00e8s avoir ajout\u00e9 le marqueur de fin \u00e0 la fin de la cha\u00eene de sortie.<\/li>\n<\/ul>\n<p>Voici un squelette du code.<\/p>\n<pre><code class=\"language-c\">void extract(const char* entree, char balise, char* sortie)\n{\n    int n = strlen(entree);\n    int curseur = 0;                       \/\/ Ligne A\n    int phase = 1;\n    for(int i=0; (i&lt;n) &amp;&amp; (phase&lt;3); i++) \n    {\n        if(phase==1)\n        {\n            \/\/ Bloc 1\n        }\n        else if (phase==2)\n        {\n            if(entree[i]!=balise)\n            {\n                \/\/ Bloc 2\n            }\n            else\n            {\n                \/\/ Bloc 3\n            }\n        }\n    }\n    \/\/ Bloc 4\n}\n<\/code><\/pre>\n<p>En <strong>ligne A<\/strong>, la variable <code>curseur<\/code> repr\u00e9sente la position du prochain caract\u00e8re \u00e0 \u00e9crire dans la cha\u00eene de sortie.<\/p>\n<p>Le <strong>bloc 1<\/strong> lit un caract\u00e8re dans la cha\u00eene d&rsquo;entr\u00e9e et passe en phase 2 si la balise est lue.<\/p>\n<p>Le <strong>bloc 2<\/strong> ajoute \u00e0 la cha\u00eene de sortie un caract\u00e8re lu dans la cha\u00eene d&rsquo;entr\u00e9e.<\/p>\n<p>Le <strong>bloc 3<\/strong> passe en phase 3, ce qui entrainera l&rsquo;arr\u00eat de la boucle.<\/p>\n<p>Le <strong>bloc 4<\/strong> ajoute le marqueur de fin \u00e0 la cha\u00eene de sortie.<\/p>\n<p>Vous devez compl\u00e9ter ces 4 blocs, dont certains ne comportent qu&rsquo;une seule ligne de code.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice1<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\">void extract(const char* entree, char balise, char* sortie)\n{\n    int n = strlen(entree);\n    int curseur = 0;\n    int phase = 1;\n    for(int i=0; (i&lt;n) &amp;&amp; (phase&lt;3); i++)\n    {\n        if(phase==1)\n        {\/\/ Avant la premi\u00e8re balise\n            if(entree[i]==balise) phase = 2;\n        }\n        else if (phase==2)\n        {\/\/ Apr\u00e8s premi\u00e8re balise\n            if(entree[i]!=balise)\n            {\n                \/\/ Bloc 2\n            }\n            else\n            {\/\/ La deuxi\u00e8me balise est lue\n                phase=3;\n            }\n        }\n    }\n    sortie[curseur] = 0;\n}\n<\/code><\/pre>\n<p>Les blocs 1, 3 et 4 ont \u00e9t\u00e9 pourvus. Il reste le bloc 2 qui est charg\u00e9 d&rsquo;ajouter un caract\u00e8re \u00e0 la cha\u00eene de sortie.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Solution<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\">void extract(const char* entree, char balise, char* sortie)\n{\n    int n = strlen(entree);\n    int curseur = 0;\n    int phase = 1;\n    for(int i=0; (i&lt;n) &amp;&amp; (phase&lt;3); i++)\n    {\n        if(phase==1)\n        {\/\/ Avant la premi\u00e8re balise\n            if(entree[i]==balise) phase = 2;\n        }\n        else if (phase==2)\n        {\/\/ Apr\u00e8s premi\u00e8re balise\n            if(entree[i]!=balise)\n            {\/\/ Avant deuxi\u00e8me balise\n                sortie[curseur] = entree[i];\n                curseur++;\n            }\n            else\n            {\/\/ La deuxi\u00e8me balise est lue\n                phase=3;\n            }\n        }\n    }\n    sortie[curseur] = 0;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<p><strong>Question suppl\u00e9mentaire.<\/strong><\/p>\n<p>Impl\u00e9mentez une fonction&#8230;<\/p>\n<pre><code class=\"language-c\">void extract1(char* entree, char balise)\n<\/code><\/pre>\n<p>&#8230;qui fait la m\u00eame chose que <code>extract<\/code>, mais en rempla\u00e7ant la cha\u00eene d&rsquo;entr\u00e9e par la cha\u00eene extraite. Cette fonction <strong>doit appeler<\/strong> la fonction <code>extract<\/code>.<\/p>\n<p>Par exemple, l&rsquo;ex\u00e9cution de la fonction <code>main<\/code> suivante&#8230;<\/p>\n<pre><code class=\"language-c\">int main()\n{\n    char entree[] = \"abcd 12#xyz12#123\";\n    extract1(entree, '#');\n    printf(\"%s\\n\", entree);\n    return 0;\n}\n<\/code><\/pre>\n<p>&#8230;affiche <code>xyz12<\/code>.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Solution<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\">void extract1(char* entree, char balise)\n{\n    char sortie[strlen(entree)+1];\n    extract(entree, balise, sortie);\n    strcpy(entree, sortie);\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h4><a id=\"exercice-d-entrainement-d-ent2-3\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement D.ent2.3<\/h4>\n<p>Vous devez impl\u00e9menter une fonction&#8230;<\/p>\n<pre><code class=\"language-c\">int str2u(const char* str, unsigned* res)\n<\/code><\/pre>\n<p>&#8230;qui convertit en un entier une cha\u00eene repr\u00e9sentant un entier en base 2.<\/p>\n<p>On appelle <strong>cha\u00eene d&rsquo;entr\u00e9e<\/strong> la cha\u00eene d\u00e9sign\u00e9e par <code>str<\/code>. On appelle <strong>valeur de sortie<\/strong> (\u00e0 ne pas confondre avec la valeur de retour) la valeur de la variable point\u00e9e par <code>res<\/code> \u00e0 l&rsquo;issue de l&rsquo;ex\u00e9cution de la fonction. Si la cha\u00eene d&rsquo;entr\u00e9e est constitu\u00e9e exclusivement de caract\u00e8res <code>'0'<\/code> et \/ ou <code>'1'<\/code>, la valeur de sortie est l&rsquo;entier dont la cha\u00eene d&rsquo;entr\u00e9e est la repr\u00e9sentation en base 2 et la valeur de retour est 1. Dans le cas contraire, la valeur de sortie est ind\u00e9termin\u00e9e et la valeur de retour est 0.<\/p>\n<p>Voici un exemple d&rsquo;utilisation pouvant faire office de test de la fonction.<\/p>\n<pre><code class=\"language-c\">int main()\n{\n    char s[] = \"011101\";\n    unsigned resultat;\n    int status = str2u(s, &amp;resultat);\n    if(status)\n    {\n        printf(\"%X\\n\", resultat);\n    }\n    else\n    {\n        printf(\"Format incorrect\\n\");\n    }\n\n    return 0;\n}\n<\/code><\/pre>\n<p>La valeur affich\u00e9e \u00e0 l&rsquo;ex\u00e9cution est <code>1D<\/code>.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice1<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>Le principe de conversion le plus simple est le suivant :<\/p>\n<ul>\n<li>On initialise la valeur de sortie \u00e0 0. C&rsquo;est tr\u00e8s important.<\/li>\n<li>On utilise une variable <code>poids<\/code> initialis\u00e9e \u00e0 1.<\/li>\n<li>On parcourt la cha\u00eene d&rsquo;entr\u00e9e en partant de la fin. Si un caract\u00e8re autre que <code>'0'<\/code> ou <code>'1'<\/code> est lu, on retourne imm\u00e9diatement 0. Si le caract\u00e8re <code>'1'<\/code> est lu, on ajoute <code>poids<\/code> \u00e0 la valeur de sortie. \u00c0 chaque it\u00e9ration, on multiplie <code>poids<\/code> par 2.<\/li>\n<\/ul>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice2<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>Voici une version incompl\u00e8te de la solution.<\/p>\n<pre><code class=\"language-c\">int str2u(const char* str, unsigned* res)\n{\n    unsigned poids = 1;\n    *res = 0;\n    for(int i=strlen(str)-1; i &gt;= 0; i--)\n    {\n        if(str[i]=='1')\n        {\n            \/\/ \u00c0 compl\u00e9ter\n        }\n        else if(str[i] != '0')\n        {\n            return 0;\n        }\n        \/\/ \u00c0 compl\u00e9ter\n    }\n    return 1;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Solution<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\">int str2u(const char* str, unsigned* res)\n{\n    unsigned poids = 1;\n    *res = 0;\n    for(int i=strlen(str)-1; i &gt;= 0; i--)\n    {\n        if(str[i]=='1')\n        {\n            *res = *res + poids;\n        }\n        else if(str[i] != '0')\n        {\n            return 0;\n        }\n        poids = poids * 2;\n    }\n    return 1;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<p><strong>Question suppl\u00e9mentaire.<\/strong><\/p>\n<p>Compl\u00e9tez le programme suivant pour qu&rsquo;il affiche en d\u00e9cimal la valeur binaire saisie en ligne de commande. Si la valeur saisie n&rsquo;est pas constitu\u00e9e de 0 et 1, le programme affiche <code>Format incorrect<\/code>. Ce programme doit utiliser la fonction <code>str2u<\/code>.<\/p>\n<pre><code class=\"language-c\">int main(int argc, char* argv[])\n{\n    if(argc != 2)\n    {\n        printf(\"Un argument attendu\\n\");\n        exit(1);\n    }\n    \/\/ \u00c0 compl\u00e9ter\n    return 0;\n}\n<\/code><\/pre>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Solution<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\">int main(int argc, char* argv[])\n{\n    if(argc != 2)\n    {\n        printf(\"Un argument attendu\\n\");\n        exit(1);\n    }\n    unsigned resultat;\n    int status = str2u(argv[1], &amp;resultat);\n    if(status)\n    {\n        printf(\"%d\\n\", resultat);\n    }\n    else\n    {\n        printf(\"Format incorrect\\n\");\n    }\n    return 0;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h3><a id=\"it%C3%A9ration-d-ent3\" class=\"anchor\" aria-hidden=\"true\"><\/a>It\u00e9ration D.ent3<\/h3>\n<h4><a id=\"exercice-d-entrainement-d-ent3-1\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement D.ent3.1<\/h4>\n<p><strong>Question 1.<\/strong> Sans utiliser de compilateur, donnez les affichages r\u00e9alis\u00e9s par l&rsquo;ex\u00e9cution des lignes de code suivantes.<\/p>\n<pre><code class=\"language-c\">    char s1[20] = \"aaaaaa\";\n    printf(\"%s %s %s\\n\", s1, s1+2, s1+4);          \n<\/code><\/pre>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-plain_text\">aaaaaa aaaa aa\n<\/code><\/pre>\n<p>Les caract\u00e8res affich\u00e9s sont ceux compris entre l&rsquo;adresse d\u00e9signant la cha\u00eene et le marqueur de fin.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<p><strong>Question 2.<\/strong> M\u00eame question avec les lignes suivantes.<\/p>\n<pre><code class=\"language-c\">    char s2[20] = {0};\n    for(int i=0; i&lt;6; i++) s2[i] = 'D'+i;\n    printf(\"%s\\n\", s2);  \n<\/code><\/pre>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>La notation <code>'D'<\/code> d\u00e9signe \u00e0 la fois le caract\u00e8re D et son code <code>ASCII<\/code>, puisque le langage C ne fait aucune diff\u00e9rence entre les deux. Donc <code>'D'+1<\/code> est le code ASCII du caract\u00e8re E, \u00e9quivalent \u00e0 <code>'E'<\/code>, etc. Comme le tableau est remplis de 0 \u00e0 l&rsquo;initialisation, on aura un marqueur de fin imm\u00e9diatement apr\u00e8s le dernier caract\u00e8re \u00e9crit dans le tableau par la boucle <code>for<\/code>.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-plain_text\">DEFGHI\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<p><strong>Question 3.<\/strong> M\u00eame question avec les lignes suivantes.<\/p>\n<pre><code class=\"language-c\">    char s3[20] = \"abcdef\";\n    char r3[20] = {'X'};\n    strcat(r3,s3);\n    printf(\"%s\\n\", r3);\n<\/code><\/pre>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>Le tableau d\u00e9sign\u00e9 par r3 est initialis\u00e9 avec le caract\u00e8re <code>'X'<\/code> suivi de 19 valeur 0. Il faut retenir que lorsqu&rsquo;un tableau est initialis\u00e9, toutes ces cellules re\u00e7oivent une valeur et que celles situ\u00e9es au del\u00e0 des valeurs d&rsquo;initialisation donn\u00e9es explicitement prennent la valeur 0.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-plain_text\">Xabcdef\n<\/code><\/pre>\n<p>Le 0 situ\u00e9 juste apr\u00e8s le caract\u00e8re <code>'X'<\/code> fait office de marqueur de fin de cha\u00eene. Le r\u00e9sultat est donc la concat\u00e9nation des cha\u00eenes <code>\"X\"<\/code> et <code>\"abcdef\"<\/code>.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<p><strong>Question 4.<\/strong> M\u00eame question avec les lignes suivantes.<\/p>\n<pre><code class=\"language-c\">    char s4[20] = \"abcdef\";\n\t  char* p = s4+2;\n    while(*p) {(*p)++; p++;}\n    printf(\"%s\\n\", s4);\n<\/code><\/pre>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p><code>*p<\/code> d\u00e9signe le caract\u00e8re point\u00e9 par <code>p<\/code>. La condition de contr\u00f4le de la boucle <code>while<\/code> est donc vraie tant que <code>p<\/code> ne pointe pas le marqueur de fin, c&rsquo;est \u00e0 dire que <code>*p<\/code> est diff\u00e9rent de 0. <code>(*p)++<\/code> incl\u00e9mente le code <code>ASCII<\/code> du caract\u00e8re point\u00e9 alors que <code>p++<\/code> incr\u00e9mente le pointeur.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-plain_text\">abdefg\n<\/code><\/pre>\n<p>Tous les caract\u00e8res \u00e0 partir du troisi\u00e8me sont incr\u00e9ment\u00e9s.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h4><a id=\"exercice-d-entrainement-d-ent3-2\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement D.ent3.2<\/h4>\n<p>Vous devez impl\u00e9menter une fonction&#8230;<\/p>\n<pre><code class=\"language-c\">int supprime(char* str, int pos)\n<\/code><\/pre>\n<p>&#8230;qui supprime dans la cha\u00eene d\u00e9sign\u00e9e par <code>str<\/code> le caract\u00e8re situ\u00e9 en position <code>pos<\/code>. Par exemple, si la cha\u00eene est <code>\"abcdefghi\"<\/code> et que <code>pos<\/code> vaut 4, la cha\u00eene devient <code>\"abcdfghi\"<\/code>. Le caract\u00e8re <code>'e'<\/code>, situ\u00e9 en position 4, est supprim\u00e9.<\/p>\n<p>Dans un premier temps, impl\u00e9mentez une fonction <code>main<\/code> qui retire le caract\u00e8re situ\u00e9 en position 4 dans la cha\u00eene <code>\"abcdefghi\"<\/code> et affiche le r\u00e9sultat en supposant que la fonction <code>supprime<\/code> est correctement d\u00e9finie.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Solution<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\">int main(int argc, char* argv[])\n{\n    char s[] = \"abcdefghi\";\n    supprime(s, 4);\n    printf(\"%s\\n\", s);\n    return 0;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<p>\u00c0 pr\u00e9sent, donnez la d\u00e9finition (le code) de la fonction <code>supprime<\/code>.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>Ce code est tr\u00e8s court. Il suffit de parcourir la cha\u00eene d&rsquo;entr\u00e9e entre la position <code>pos<\/code> et son dernier caract\u00e8re et d&rsquo;\u00e9crire \u00e0 chaque position parcourue le caract\u00e8re situ\u00e9 dans la position suivante.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Solution<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\">int supprime(char* str, int pos)\n{\n    int n = strlen(str);\n    for(int i=pos; i&lt;n; i++)\n    {\n        str[i] = str[i+1];\n    }\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h4><a id=\"exercice-d-entrainement-d-ent3-3\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement D.ent3.3<\/h4>\n<p>Vous devez impl\u00e9menter une fonction&#8230;<\/p>\n<pre><code class=\"language-c\">void afficheMots(const char str[])\n<\/code><\/pre>\n<p>&#8230;qui affiche tous les mots de la cha\u00eene d\u00e9sign\u00e9e par <code>str<\/code> en allant \u00e0 la ligne apr\u00e8s chaque mot. On consid\u00e8re comme \u00e9tant un mot toute partie de cha\u00eene qui ne commence pas par un espace et qui se termine par un espace ou par le marqueur de fin.<\/p>\n<p>L&rsquo;ex\u00e9cution de la fonction main suivante&#8230;<\/p>\n<pre><code class=\"language-c\">int main(int argc, char* argv[])\n{\n    char s[] = \"Bonjour tout le monde\";\n    afficheMots(s);\n    return 0;\n}\n<\/code><\/pre>\n<p>&#8230;doit produire l&rsquo;affichage :<\/p>\n<pre><code class=\"language-plain_text\">Bonjour\ntout\nle\nmonde\n<\/code><\/pre>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice1<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>Il y a plusieurs approches possibles. Celle propos\u00e9e ici consiste \u00e0 d\u00e9composer le probl\u00e8me \u00e0 r\u00e9soudre en utilisant deux fonctions. La fonction \u00e0 r\u00e9aliser, <code>afficheMots<\/code>, appelle une fonction <code>affiche1mot<\/code> qui est charg\u00e9e d&rsquo;afficher chacun des mots.<\/p>\n<pre><code class=\"language-c\">int affiche1mot(const char str[], int pos)\n{\n    \/\/ \u00c0 compl\u00e9ter\n}\n\nvoid afficheMots(const char str[])\n{\n    int i=0;\n    while(str[i]!=0)\n    {\n        i = affiche1mot(str, i);\n    }\n}\n<\/code><\/pre>\n<p>Le code de la fonction <code>afficheMots<\/code> est donn\u00e9. Il reste \u00e0 impl\u00e9menter la fonction <code>affiche1mot<\/code>. Cette fonction affiche le mot commen\u00e7ant en position <code>pos<\/code> dans la cha\u00eene d\u00e9sign\u00e9e par <code>str<\/code>. Elle retourne la position du mot suivant ou, si le mot affich\u00e9 \u00e9tait le dernier, du marqueur de fin.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice2<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\">int affiche1mot(const char str[], int pos)\n{\n    while((str[pos]!=' ')&amp;&amp;(str[pos]!=0))\n    {\n        \/\/ \u00c0 compl\u00e9ter\n    }\n    printf(\"\\n\");    \n    \/\/ \u00c0 compl\u00e9ter\n    return pos;\n}\n<\/code><\/pre>\n<p>Le premier bloc \u00e0 compl\u00e9ter lit et affiche un caract\u00e8re du mot en cours d&rsquo;affichage. Le deuxi\u00e8me bloc \u00e0 compl\u00e9ter passe les espaces situ\u00e9s apr\u00e8s ce mots de mani\u00e8re \u00e0 ce que la valeur retourn\u00e9e soit la position du d\u00e9but du mot suivant (ou du marqueur de fin de cha\u00eene).<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Solution<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\">int affiche1mot(const char str[], int pos)\n{\n    while((str[pos]!=' ')&amp;&amp;(str[pos]!=0))\n    {\n        printf(\"%c\",str[pos]);\n        pos++;\n    }\n    printf(\"\\n\");    \n    while(str[pos]==' ') pos++;\n    return pos;\n}\n\nvoid afficheMots(const char str[])\n{\n    int i=0;\n    while(str[i]!=0)\n    {\n        i = affiche1mot(str, i);\n    }\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<h2><a id=\"activit%C3%A9-de-consolidation-d-top\" class=\"anchor\" aria-hidden=\"true\"><\/a>Activit\u00e9 de consolidation D.top<\/h2>\n<p>R\u00e9aliser cette activit\u00e9 consiste \u00e0 traiter un des exercices de consolidation propos\u00e9s. Si vous r\u00e9alisez plusieurs fois cette activit\u00e9, laissez passer au moins une semaine entre chaque it\u00e9ration et traitez \u00e0 chaque fois un exercice diff\u00e9rent.<\/p>\n<h3><a id=\"exercice-de-consolidation-d-top1\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de consolidation D.top1<\/h3>\n<p>Vous devez impl\u00e9menter 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 <code>ana<\/code> et qu&rsquo;on saisi dans la console&#8230;<\/p>\n<pre><code class=\"language-plain_text\">&gt; ana abc\n<\/code><\/pre>\n<p>&#8230;On obtient l&rsquo;affichage :<\/p>\n<pre><code class=\"language-plain_text\">abc\nacb\nbac\nbca\ncab\ncba\n<\/code><\/pre>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice1<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>La r\u00e9cursivit\u00e9 est votre amie. On peut utiliser la fonction <code>main<\/code> suivante :<\/p>\n<pre><code class=\"language-c\">int main(int argc, char* argv[])\n{\n    if(argc!=2)\n    {\n        printf(\"Exactement 1 argument est attendu\\n\");\n        exit(1);\n    }\n    prefixAna(\"\",argv[1]);\n    return 0;\n}\n<\/code><\/pre>\n<p>Elle appelle la fonction r\u00e9cursive <code>prefixAna<\/code> que vous devez impl\u00e9menter :<\/p>\n<pre><code class=\"language-c\">void prefixAna(const char* prefix, const char* suffix)\n<\/code><\/pre>\n<p>Un appel de cette fonction affiche tous les anagrammes de la cha\u00eene d\u00e9sign\u00e9e par <code>suffix<\/code>, chacun pr\u00e9c\u00e9d\u00e9 de la cha\u00eene d\u00e9sign\u00e9e par <code>prefix<\/code>. Par exemple, <code>prefixAna(\"AB\", \"CD\")<\/code> affiche <code>ABCD<\/code> et <code>ABDC<\/code>.<\/p>\n<p>Le principe utilis\u00e9 est simple mais sa programmation en C est un peu technique.<\/p>\n<ul>\n<li>Si le suffixe est vide, le pr\u00e9fixe est affich\u00e9.<\/li>\n<li>Si le suffixe n&rsquo;est pas vide, alors pour chaque caract\u00e8re <code>c<\/code> du suffixe, on fait un appel r\u00e9cursif <code>prefixAna(p,s)<\/code> o\u00f9 <code>p<\/code> est l&rsquo;ancien pr\u00e9fixe auquel on a ajout\u00e9 <code>c<\/code> et ou <code>s<\/code> est lancien suffixe duquel on a retir\u00e9 <code>c<\/code>.<\/li>\n<\/ul>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice1<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\">void prefixAna(const char* prefix, const char* suffix)\n{\n    int sizePref = strlen(prefix);        \n    int sizeSuff = strlen(suffix);\n    if(sizeSuff==0) printf(\"%s\\n\",prefix);  \/\/ Ligne A\n    char nouvPref[sizePref+2];              \/\/ Ligne B\n    char nouvSuff[sizeSuff];                \/\/ Ligne C\n    strcpy(nouvPref, prefix);               \/\/ Ligne D\n    nouvPref[sizePref+1] = 0;               \/\/ Ligne E\n    nouvSuff[sizeSuff-1] = 0;               \/\/ Ligne F\n    for(int i = 0; i&lt;sizeSuff; i++)\n    {\n        \/\/ \u00c0 compl\u00e9ter\n    }\n}\n<\/code><\/pre>\n<p><strong>La ligne A<\/strong> traite le cas trivial dans lequel le suffixe est vide et on affiche juste le pr\u00e9fixe.<\/p>\n<p><strong>Les lignes B et C<\/strong> cr\u00e9ent les tableaux qui seront utilis\u00e9s pour placer les pr\u00e9fixes et les suffixes des appels r\u00e9cursifs. Le nouveau pr\u00e9fixe comportera un caract\u00e8re de plus que l&rsquo;ancien et le nouveau suffixe comportera un caract\u00e8re de moins que l&rsquo;ancien.<\/p>\n<p><strong>La ligne D<\/strong> recopie l&rsquo;ancien pr\u00e9fixe dans le tableau qui contiendra les nouveaux pr\u00e9fixes des appels r\u00e9cursifs.<\/p>\n<p><strong>Les lignes E et F<\/strong> placent les marqueurs de fin dans les tableaux qui contiendront les pr\u00e9fixes et suffixes des appels r\u00e9cursifs.<\/p>\n<p>Par exemple, si le pr\u00e9fixe est \u00ab\u00a0AB\u00a0\u00bb et le suffixe \u00ab\u00a0CDE\u00a0\u00bb, alors les contenus des tableaux <code>nouvPref<\/code> et <code>nouvSuff<\/code> \u00e0 l&rsquo;issue de l&rsquo;ex\u00e9cution de la ligne F sont les suivants :<\/p>\n<pre><code class=\"language-plain_text\">nouvPref : 'A' 'B'  ?  0\nnouvSuff :  ?   ?   0 \n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice2<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\">void prefixAna(const char* prefix, const char* suffix)\n{\n    int sizePref = strlen(prefix);\n    int sizeSuff = strlen(suffix);\n    if(sizeSuff==0) printf(\"--&gt; %s\\n\",prefix);\n    char nouvPref[sizePref+2];\n    char nouvSuff[sizeSuff];\n    strcpy(nouvPref, prefix);\n    nouvPref[sizePref+1] = 0;\n    nouvSuff[sizeSuff-1] = 0;\n    for(int i = 0; i&lt;sizeSuff; i++)       \/\/ Boucle 1\n    {\n        nouvPref[sizePref] = suffix[i];   \/\/ Ligne R\n        int k=0;                          \/\/ Ligne S\n        for(int j=0; j&lt;sizeSuff; j++)     \/\/ Boucle 2\n        {\n            \/\/ \u00c0 compl\u00e9ter\n        }\n        prefixAna(nouvPref,nouvSuff);     \/\/ Ligne T\n    }\n}\n<\/code><\/pre>\n<p><strong>La ligne R<\/strong> ajoute \u00e0 la fin du nouveau pr\u00e9fixe (celui qui sera utilis\u00e9 par l&rsquo;appel r\u00e9cursif), le caract\u00e8re situ\u00e9 en position <code>i<\/code> dans l&rsquo;ancien suffixe.<\/p>\n<p><strong>La ligne S<\/strong> d\u00e9clare et initialise \u00e0 0 la variable <code>k<\/code> qui indique la position \u00e0 laquelle sera ajout\u00e9 chaque caract\u00e8re au nouveau suffixe lors de sa construction par la <strong>boucle 2<\/strong>. \u00c0 chaque fois qu&rsquo;un caract\u00e8re sera ajout\u00e9 au nouveau suffixe, <code>k<\/code> sera incr\u00e9ment\u00e9.<\/p>\n<p><strong>La ligne T<\/strong> r\u00e9alise un appel r\u00e9cursif avec :<\/p>\n<ul>\n<li>un nouveau pr\u00e9fixe qui est l&rsquo;ancien auquel le caract\u00e8re situ\u00e9 en position <code>i<\/code> dans l&rsquo;ancien suffixe est ajout\u00e9.<\/li>\n<li>un nouveau suffixe qui est l&rsquo;ancien duquel ce m\u00eame caract\u00e8re a \u00e9t\u00e9 retir\u00e9.<\/li>\n<\/ul>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Solution<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\">void prefixAna(const char* prefix, const char* suffix)\n{\n    int sizePref = strlen(prefix);\n    int sizeSuff = strlen(suffix);\n    if(sizeSuff==0) printf(\"--&gt; %s\\n\",prefix);\n    char nouvPref[sizePref+2];\n    char nouvSuff[sizeSuff];\n    strcpy(nouvPref, prefix);\n    nouvPref[sizePref+1] = 0;\n    nouvSuff[sizeSuff-1] = 0;\n    for(int i = 0; i&lt;sizeSuff; i++)\n    {\n        nouvPref[sizePref] = suffix[i];\n        int k=0;\n        for(int j=0; j&lt;sizeSuff; j++)\n        {\n            if(j!=i) \n            {\n                nouvSuff[k] = suffix[j];\n                k++;\n            }\n        }\n        prefixAna(nouvPref,nouvSuff);\n    }\n}\n\nint main(int argc, char* argv[])\n{\n    if(argc!=2)\n    {\n        printf(\"Exactement 1 argument est attendu\\n\");\n        exit(1);\n    }\n    prefixAna(\"\",argv[1]);\n    return 0;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h3><a id=\"exercice-de-consolidation-d-top2\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de consolidation D.top2<\/h3>\n<p>Vous devez impl\u00e9menter une fonction qui accepte une cha\u00eene en param\u00e8tres et qui v\u00e9rifie si cette cha\u00eene repr\u00e9sente un nombre d\u00e9cimal, c&rsquo;est \u00e0 dire si elle est constitu\u00e9e d&rsquo;un signe <code>-<\/code> optionnel, sauf si le nombre est 0, suivi d&rsquo;une partie enti\u00e8re, suivie d&rsquo;une partie d\u00e9cimale optionnelle.<\/p>\n<p>S&rsquo;il y a une partie d\u00e9cimale, la partie enti\u00e8re est soit vide, soit constitu\u00e9e uniquement du chiffre 0, soit constitu\u00e9e d&rsquo;un chiffre 1 \u00e0 9 suivi d&rsquo;un nombre quelconque de chiffres 0 \u00e0 9. S&rsquo;il n&rsquo;y a pas de partie d\u00e9cimale, la partie enti\u00e8re est soit constitu\u00e9e uniquement du chiffre 0, soit constitu\u00e9e d&rsquo;un chiffre 1 \u00e0 9 suivi d&rsquo;un nombre quelconque de chiffres 0 \u00e0 9.<\/p>\n<p>S&rsquo;il y a une partie enti\u00e8re, la partie d\u00e9cimale est constitu\u00e9e d&rsquo;un point qui est suivit soit du chiffre 0, soit d&rsquo;un nombre quelconque non nul de chiffres de 0 \u00e0 9. Si la partie enti\u00e8re est vide, la partie d\u00e9cimale est constitu\u00e9e d&rsquo;un nombre quelconque non nul de chiffres de 0 \u00e0 9.<\/p>\n<p>Voici des exemples valides. Tous pourraient \u00eatre pr\u00e9c\u00e9d\u00e9s du signe <code>-<\/code> sauf le premier<\/p>\n<pre><code class=\"language-plain_text\">0   0.0056   .008   0.09   0.120   12.014  14\n<\/code><\/pre>\n<p>Voici des exemples non valides.<\/p>\n<pre><code class=\"language-plain_text\">00   89.   9.88.0   0067   --0.33   12a.6    \n<\/code><\/pre>\n<p>La fonction accepte en param\u00e8tre une cha\u00eene de caract\u00e8re et retourne un entier. La valeur de retour doit \u00eatre 1 si la cha\u00eene repr\u00e9sente un nombre valide et 0 dans le cas contraire.<\/p>\n<p>La fonction main suivante&#8230;<\/p>\n<pre><code class=\"language-c\">int main(int argc, char* argv[])\n{\n    printf(\"%d \",verifNbrDec(\"0\"));\n    printf(\"%d \",verifNbrDec(\"0.0056\"));\n    printf(\"%d \",verifNbrDec(\"0.008\"));\n    printf(\"%d \",verifNbrDec(\"0.09\"));\n    printf(\"%d \",verifNbrDec(\"0.120\"));\n    printf(\"%d \",verifNbrDec(\"12.014\"));\n    printf(\"%d\\n\",verifNbrDec(\"14\"));\n    \n    printf(\"%d \",verifNbrDec(\"00\"));\n    printf(\"%d \",verifNbrDec(\"89.\"));\n    printf(\"%d \",verifNbrDec(\"9.88.0\"));\n    printf(\"%d \",verifNbrDec(\"0067\"));\n    printf(\"%d \",verifNbrDec(\"--33\"));\n    printf(\"%d\\n\",verifNbrDec(\"12a.6\"));\n    return 0;\n}\n<\/code><\/pre>\n<p>&#8230;devrait afficher :<\/p>\n<pre><code class=\"language-plain_text\">1 1 1 1 1 1 1\n0 0 0 0 0 0\n<\/code><\/pre>\n<p>Pour \u00e9viter de produire une code tr\u00e8s compliqu\u00e9 et tr\u00e8s difficile \u00e0 mettre au point, vous devez baser votre solution sur l&rsquo;automate fini ci-dessous.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/01\/6-1.png\" alt=\"image-20220101234859372\" \/><\/p>\n<p>L&rsquo;\u00e9tat initial est 1. Les \u00e9tats 3, 4 et 6 sont des \u00e9tats d&rsquo;acceptation, c&rsquo;est \u00e0 dire que si, lorsque tous les caract\u00e8res de la cha\u00eene d&rsquo;entr\u00e9e ont \u00e9t\u00e9 lus, l&rsquo;automate est dans cet \u00e9tat, alors la cha\u00eene est valide. Les fl\u00e8ches indiquent les transitions autoris\u00e9es. Par exemple, dans l&rsquo;\u00e9tat 1, si le caract\u00e8re 0 est lu alors on passe dans l&rsquo;\u00e9tat 4, si le caract\u00e8re <code>-<\/code> est lu alors on passe dans l&rsquo;\u00e9tat 2, si un caract\u00e8re 1 \u00e0 9 est lu alors on passe dans l&rsquo;\u00e9tat 3, et si tout autre caract\u00e8re est lu, la fonction retourne imm\u00e9diatement 0.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>Voici un squelette de code \u00e0 compl\u00e9ter.<\/p>\n<pre><code class=\"language-c\">int verifNbrDec(const char* str)\n{\n    int etat = 1;\n    int n = strlen(str);\n    for(int i=0; i&lt;n; i++)\n    {\n        char c = str[i];\n        if(etat==1)\n        {\n            \/\/ \u00c0 compl\u00e9ter\n        }\n        else if(etat==2)\n        {\n            \/\/ \u00c0 compl\u00e9ter\n        }\n        else if(etat==3)\n        {\n            \/\/ \u00c0 compl\u00e9ter\n        }\n        else if(etat==4)\n        {\n            \/\/ \u00c0 compl\u00e9ter\n        }\n        else if(etat==5)\n        {\n            \/\/ \u00c0 compl\u00e9ter\n        }\n        else\n        {\n            \/\/ \u00c0 compl\u00e9ter\n        }\n    }\n    return (etat==3) || (etat==4) || (etat==6);\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Solution<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\">int verifNbrDec(const char* str)\n{\n    int etat = 1;\n    int n = strlen(str);\n    for(int i=0; i&lt;n; i++)\n    {\n        char c = str[i];\n        if(etat==1)\n        {\n            if(c=='-') etat=2;\n            else if(c=='0') etat=4;\n            else if((c&gt;='1')&amp;&amp;(c&lt;='9')) etat=3;\n            else return 0;\n        }\n        else if(etat==2)\n        {\n            if(c=='.') etat=5;\n            else if((c&gt;='1')&amp;&amp;(c&lt;='9')) etat=3;\n            else return 0;\n        }\n        else if(etat==3)\n        {\n            if(c=='.') etat=5;\n            else if((c&gt;='0')&amp;&amp;(c&lt;='9')) etat=3;\n            else return 0;\n        }\n        else if(etat==4)\n        {\n            if(c=='.') etat=5;\n            else return 0;\n        }\n        else if(etat==5)\n        {\n            if((c&gt;='0')&amp;&amp;(c&lt;='9')) etat=6;\n            else return 0;\n        }\n        else\n        {\n            if((c&gt;='0')&amp;&amp;(c&lt;='9')) etat=6;\n            else return 0;\n        }\n    }\n    return (etat==3) || (etat==4) || (etat==6);\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n","protected":false},"excerpt":{"rendered":"<p>Par O. Bailleux, Ma\u00eetre de conf\u00e9rences HDR \u00e0 l&rsquo;universit\u00e9 de Bourgogne. Cha\u00eenes de caract\u00e8res en C Les activit\u00e9s #.dec (dec pour D\u00e9couverte) consistent \u00e0 \u00e9tudier des pr\u00e9sentations explicatives et \u00e0 traiter tous les exercices de d\u00e9couverte propos\u00e9s. Si vous ne r\u00e9pondez pas correctement \u00e0 un exercice de d\u00e9couverte, revenez en arri\u00e8re pour relire les explications [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"","sticky":false,"template":"","format":"standard","meta":{"_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[2],"tags":[],"class_list":["post-53","post","type-post","status-publish","format-standard","hentry","category-c-et-cpp","entry"],"jetpack_sharing_enabled":true,"jetpack_featured_media_url":"","_links":{"self":[{"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/posts\/53","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/comments?post=53"}],"version-history":[{"count":2,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/posts\/53\/revisions"}],"predecessor-version":[{"id":202,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/posts\/53\/revisions\/202"}],"wp:attachment":[{"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/media?parent=53"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/categories?post=53"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/tags?post=53"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}