{"id":278,"date":"2022-02-25T21:07:10","date_gmt":"2022-02-25T21:07:10","guid":{"rendered":"https:\/\/9h15.net\/activ\/?p=278"},"modified":"2022-02-25T21:07:21","modified_gmt":"2022-02-25T21:07:21","slug":"c-et-c-tp5","status":"publish","type":"post","link":"https:\/\/9h15.net\/activ\/c-et-c-tp5\/","title":{"rendered":"C et C++ TP5"},"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=\"calculer-sans-parenth%C3%A8ses\" class=\"anchor\" aria-hidden=\"true\"><span class=\"octicon octicon-link\"><\/span><\/a>Calculer sans parenth\u00e8ses<\/h1>\n<p>La prochaine \u00e9valuation de TP sera bas\u00e9e sur ce sujet et pourra rapporter de 0 \u00e0 10 points sur votre note de TP.<\/p>\n<p>Pour aborder ce TP, il faut ma\u00eetriser les parties A, C et D du cours. Dans le curriculum de r\u00e9f\u00e9rence, la partie D devait \u00eatre (id\u00e9alement) ma\u00eetris\u00e9e le 7 f\u00e9vrier.<\/p>\n<p>Si vous n&rsquo;avez pas encore \u00e9tudi\u00e9 et raisonnablement ma\u00eetris\u00e9 la partie D, alors vous \u00eates en difficult\u00e9. Il vous est conseill\u00e9 de contacter, si ce n&rsquo;est d\u00e9j\u00e0 fait, le responsable de l&rsquo;UE (M. Bailleux) pour discuter avec lui de la meilleure strat\u00e9gie d&rsquo;apprentissage \u00e0 adopter. Sachez que les cha\u00eenes de caract\u00e8res, abord\u00e9es dans la partie C, sont avant tout des tableaux et que vos comp\u00e9tences des parties A et C peuvent vous permettre de r\u00e9pondre \u00e0 certaines questions.<\/p>\n<p>Les 10 points de la premi\u00e8re \u00e9valuation pourront par ailleurs \u00eatre rattrap\u00e9s \u00e0 la deuxi\u00e8me, en cas de besoin.<\/p>\n<h2><a id=\"une-pile-de-mots\" class=\"anchor\" aria-hidden=\"true\"><span class=\"octicon octicon-link\"><\/span><\/a>Une pile de mots<\/h2>\n<p>Le but de cette partie est d&rsquo;impl\u00e9menter deux fonctions permettant d&rsquo;utiliser une simple chaine de caract\u00e8res dans le r\u00f4le d&rsquo;une <strong>pile de mots<\/strong>.<\/p>\n<ul>\n<li><code>void empile(char* pile, const char* mot)<\/code> : Empile le mot d\u00e9sign\u00e9 par le param\u00e8tre <code>mot<\/code> dans la pile d\u00e9sign\u00e9e par le param\u00e8tre <code>pile<\/code>.<\/li>\n<li><code>int depile void depile(char* pile, char* mot)<\/code> Si la pile d\u00e9sign\u00e9e par le param\u00e8tre <code>pile<\/code> est vide, place la cha\u00eene vide dans le tableau d\u00e9sign\u00e9 par le param\u00e8tre <code>mot<\/code> et retourne 0, sinon qui retire un mot de la pile, copie ce mot dans le tableau d\u00e9sign\u00e9 par le param\u00e8tre <code>mot<\/code>, et retourne 1.<\/li>\n<\/ul>\n<p>La pile est repr\u00e9sent\u00e9e par un tableau de caract\u00e8res dont la taille est d\u00e9finie par une constante.<\/p>\n<pre><code class=\"language-c\">#define CAPA 256\n<\/code><\/pre>\n<p>Une pile vide est repr\u00e9sent\u00e9e par une chaine contenant uniquement le caract\u00e8re <code>'#'<\/code>, c&rsquo;est \u00e0 dire la chaine <code>&quot;#&quot;<\/code>.<\/p>\n<p>Voici la repr\u00e9sentation d&rsquo;une pile contenant le mot <code>&quot;aaa&quot;<\/code> :<\/p>\n<pre><code class=\"language-plain_text\">&quot;#aaa#&quot;\n<\/code><\/pre>\n<p>Si on empile le mot <code>&quot;bbb&quot;<\/code>, le contenu de la chaine repr\u00e9sentant la pile est :<\/p>\n<pre><code class=\"language-plain_text\">&quot;#aaa#bbb#&quot;\n<\/code><\/pre>\n<p>Si on empile ensuite le mot <code>&quot;ccc&quot;<\/code>, le contenu devient :<\/p>\n<pre><code class=\"language-plain_text\">&quot;#aaa#bbb#ccc#&quot;\n<\/code><\/pre>\n<p>Lorsqu&rsquo;un mot est d\u00e9pil\u00e9, la pile se retrouve dans l&rsquo;\u00e9tat exact ou elle \u00e9tait avant que ce mot soit empil\u00e9.<\/p>\n<p>Voici un exemple d&rsquo;utilisation :<\/p>\n<pre><code class=\"language-c\">void essai1(void)\n{\n    char pile[CAPA];\n    strcpy(pile,&quot;#&quot;);\n    char buf[CAPA];\n    \n    empile(pile,&quot;aaa&quot;);\n    printf(&quot;%s\\n&quot;, pile);\n    \n    empile(pile,&quot;bbb&quot;);\n    printf(&quot;%s\\n&quot;, pile);\n    \n    depile(pile, buf);\n    printf(&quot;d\u00e9pil\u00e9 : %s, pile : %s\\n&quot;, buf, pile);\n    \n    depile(pile, buf);\n    printf(&quot;d\u00e9pil\u00e9 : %s, pile : %s\\n&quot;, buf, pile);\n}\n<\/code><\/pre>\n<p>L&rsquo;ex\u00e9cution de cette fonction produit les affichages :<\/p>\n<pre><code class=\"language-plain_text\">#aaa#\n#aaa#bbb#\nd\u00e9pil\u00e9 : bbb, pile : #aaa#\nd\u00e9pil\u00e9 : aaa, pile : #\n<\/code><\/pre>\n<hr \/>\n<h3><a id=\"question-1\" class=\"anchor\" aria-hidden=\"true\"><span class=\"octicon octicon-link\"><\/span><\/a>Question 1<\/h3>\n<p>Impl\u00e9mentez la fonction <code>empile<\/code> et testez-l\u00e0 en empilant des mots et en affichant la pile avec la fonction <code>printf<\/code>.<\/p>\n<h3><a id=\"question-2\" class=\"anchor\" aria-hidden=\"true\"><span class=\"octicon octicon-link\"><\/span><\/a>Question 2<\/h3>\n<p>Compl\u00e9tez la d\u00e9finition de la fonction <code>depile<\/code> esquiss\u00e9e ci-dessous. On suppose que la pile est dans un \u00e9tat correct, i.e. contient un <code>'#'<\/code> en premier caract\u00e8re, suivi \u00e9ventuellement d&rsquo;un ou plusieurs mots, tous suivi d&rsquo;un <code>'#'<\/code>.<\/p>\n<pre><code class=\"language-c\">int depile(char* pile, char* mot)\n{\n    int i = (int)strlen(pile)-1;\n    if(i == 0)\n    {\n        \/\/ \u00c0 compl\u00e9ter\n    }\n    else\n    {\n        \/\/ \u00c0 compl\u00e9ter\n        return 1;\n    }\n}\n<\/code><\/pre>\n<p>Attention, la conception de la deuxi\u00e8me partie \u00e0 compl\u00e9ter (bien que ne n\u00e9cessitant que quelques lignes de code) n\u00e9cessite un vrai travail d&rsquo;ing\u00e9nierie, c&rsquo;est \u00e0 dire d\u00e9composer le traitement \u00e0 r\u00e9aliser en plusieurs \u00e9tapes ayant chacune un r\u00f4le bien identifi\u00e9. Une phase de mise au point, avec des affichages d&rsquo;informations utiles, peut s&rsquo;av\u00e9rer n\u00e9cessaire.<\/p>\n<p>Voici les \u00e9tapes d&rsquo;ex\u00e9cution d&rsquo;une impl\u00e9mentation possible de la fonction dans le cas o\u00f9 la pile contient les mots <code>&quot;aaa&quot;<\/code> et <code>&quot;bbb&quot;<\/code>.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/02\/1-6.png\" alt=\"image-20220225133208992\" \/><\/p>\n<ol>\n<li>On place dans une variable <code>i<\/code> la position du dernier <code>#<\/code>.<\/li>\n<li>On place un 0 dans <code>pile[i]<\/code> (Pour faciliter la copie ult\u00e9rieure du dernier mot empil\u00e9).<\/li>\n<li>On d\u00e9cr\u00e9mente <code>i<\/code> jusqu&rsquo;\u00e0 ce que la case <code>pile[i]<\/code> contienne <code>#<\/code>.<\/li>\n<li>On copie la chaine commen\u00e7ant en position <code>i<\/code> dans le tableau devant recevoir le mot d\u00e9pil\u00e9.<\/li>\n<li>On place un marqueur de fin en position <code>i+1<\/code> pour que la pile s&rsquo;arr\u00eate l\u00e0 o\u00f9 se trouvait le d\u00e9but du mot qui vient d&rsquo;\u00eatre d\u00e9pil\u00e9.<\/li>\n<\/ol>\n<p>Il est important de soumettre votre solution \u00e0 une batterie de tests couvrants les situations suivantes :<\/p>\n<ul>\n<li>D\u00e9piler dans une pile vide.<\/li>\n<li>D\u00e9piler plusieurs fois de suite dans une pile non vide.<\/li>\n<li>Encha\u00eener une succession d&#8217;empilages et d\u00e9pilages.<\/li>\n<\/ul>\n<p>En r\u00e9alisant un affichage syst\u00e9matique de la pile et du mot d\u00e9pil\u00e9 apr\u00e8s chaque action.<\/p>\n<h2><a id=\"calcul-en-notation-polonaise-inverse\" class=\"anchor\" aria-hidden=\"true\"><span class=\"octicon octicon-link\"><\/span><\/a>Calcul en notation polonaise inverse<\/h2>\n<p>Quand on r\u00e9alise un calcul arithm\u00e9tique, on est parfois oblig\u00e9 d&rsquo;utiliser des parenth\u00e8ses, comme dans l&rsquo;exemple suivant :<\/p>\n<pre><code class=\"language-plain_text\">(12 - 6) * (5 + 7)\n<\/code><\/pre>\n<p>Le r\u00e9sultat est 72 alors que si on enl\u00e8ve les parenth\u00e8ses c&rsquo;est -11.<\/p>\n<p>Mais il existe un moyen de repr\u00e9senter toute expression arithm\u00e9tique parenth\u00e9s\u00e9e sous la forme d&rsquo;une suite de nombres et d&rsquo;op\u00e9rateurs, sans parenth\u00e8ses. Avec l&rsquo;exemple pr\u00e9c\u00e9dent, cela donne :<\/p>\n<pre><code class=\"language-plain_text\">12 6 - 5 7 + *\n<\/code><\/pre>\n<p>Le principe de l&rsquo;\u00e9valuation est d&rsquo;une simplicit\u00e9 d\u00e9concertante. C&rsquo;est d&rsquo;ailleurs pour cette raison qu&rsquo;il \u00e9tait utilis\u00e9 par le toutes premi\u00e8res calculatrice \u00e9lectroniques. On utilise une pile de nombres. \u00c0 chaque fois qu&rsquo;un nombre est saisi, il est empil\u00e9. Lorsqu&rsquo;un op\u00e9rateur est saisi (-, +, \/, *), deux nombres sont d\u00e9pil\u00e9s, l&rsquo;op\u00e9rateur est appliqu\u00e9 sur ces deux nombres, et le r\u00e9sultat est empil\u00e9.<\/p>\n<p>Voici les \u00e9tats successifs de la pile lors de l&rsquo;\u00e9valuation de l&rsquo;expression donn\u00e9e en exemple :<\/p>\n<pre><code class=\"language-plain_text\">12\n12 6\n6      (\u00e9valuation du -)\n6 5\n6 5 7\n6 12   (\u00e9valuation du +)\n72     (\u00e9valuation du *)\n<\/code><\/pre>\n<p>On veut faire ce genre de chose avec notre pile de chaines, sauf que cette pile contient des chaines et pas des nombres. Lors de la saisie des valeurs, cela ne pose pas de probl\u00e8me. On peut saisir des chaines repr\u00e9sentant des nombres. Mais au moment du calcul, il faudra transformer les mots d\u00e9pil\u00e9s en valeurs de type <code>int<\/code> et avant d&#8217;empiler le r\u00e9sultat, il faudra le convertir en une chaine.<\/p>\n<p>Entrainez-vous \u00e0 transposer quelques calculs parenth\u00e9s\u00e9s en notation polonaise inverse pour bien comprendre le principe :<\/p>\n<pre><code class=\"language-plain_text\">(10-2)-((2 + 5) * 3 * 5)\n(3 * 5 * 10) + (5 - 2) + (10 * 11)\n<\/code><\/pre>\n<hr \/>\n<h3><a id=\"saisir-et-convertir\" class=\"anchor\" aria-hidden=\"true\"><span class=\"octicon octicon-link\"><\/span><\/a>Saisir et convertir<\/h3>\n<p>Voici quelques moyens conseill\u00e9s pour saisir une chaine au clavier, convertir en entier une chaine repr\u00e9sentant un entier, et convertir un entier en chaine.<\/p>\n<p>Tout d&rsquo;abord, la fonction d\u00e9finie ci-dessous, que vous pouvez reprendre dans votre code source, permet de saisir au clavier une chaine d&rsquo;au plus <code>lgMax<\/code> caract\u00e8res et de la placer dans le tableau d\u00e9sign\u00e9 par <code>buffer<\/code>, qui doit \u00eatre de taille suffisante pour recueillir la cha\u00eene saisie.<\/p>\n<pre><code class=\"language-c\">void saisie(char* buffer, int lgMax)\n{\n    fgets(buffer, lgMax+1, stdin);\n    buffer[strlen(buffer)-1] = 0;\n}\n<\/code><\/pre>\n<p>Ensuite, la fonction <code>sscanf<\/code> peut permettre de traduire une cha\u00eene (du moins son plus grand pr\u00e9fixe interpr\u00e9table comme un entier)  en entier, et la fonction <code>sprintf<\/code> peut permettre de convertir un entier en chaine. Ces fonctions peuvent \u00eatre utilis\u00e9es pour traduire plusieurs donn\u00e9es en plusieurs formats en un seul appel, mais nous nous contenterons d&rsquo;un usage basique, illustr\u00e9 par cet exemple :<\/p>\n<pre><code class=\"language-c\">void exemple(void)\n{\n    char buf[CAPA];                            \/\/ Ligne A\n    \n    saisie(buf,CAPA-1);                        \/\/ Ligne B\n    printf(&quot;Chaine lue : %s\\n&quot;, buf);\n    \n    int x=0;\n    int status = sscanf(buf, &quot;%d&quot;, &amp;x);        \/\/ Ligne C\n    printf(&quot;%d entier = %d\\n&quot;, status, x);\n    \n    sprintf(buf, &quot;%d&quot;, x);                     \/\/ Ligne D\n    printf(&quot;Re-traduit en chaine : %s\\n&quot;, buf);\n}\n<\/code><\/pre>\n<p><strong>En ligne A<\/strong>, on cr\u00e9e un tableau de caract\u00e8res destin\u00e9 \u00e0 contenir le r\u00e9sultat d&rsquo;une saisie au clavier (ligne C), puis d&rsquo;une traduction d&rsquo;un entier en chaine (ligne D).<\/p>\n<p><strong>En ligne B<\/strong>, on appelle la fonction <code>saisie<\/code> pour saisir une cha\u00eene au clavier et la placer dans le tableau point\u00e9 par <code>buf<\/code>. L&rsquo;argument <code>CAPA-1<\/code> limite la taille de la chaine saisie pour \u00e9viter un d\u00e9bordement.<\/p>\n<p><strong>En ligne C<\/strong>, on utilise <code>sscanf<\/code> pour &quot;lire&quot; un entier dans la chaine contenue dans le tableau d\u00e9sign\u00e9 par <code>buf<\/code>. L&rsquo;entier lu est plac\u00e9 dans la variable <code>x<\/code>.<\/p>\n<p><strong>En ligne D<\/strong>, on fait l&rsquo;op\u00e9ration inverse. On utilise <code>sprintf<\/code> pour &quot;\u00e9crire&quot; un entier sous forme de cha\u00eene dans le tableau d\u00e9sign\u00e9 par <code>buf<\/code>. La fonction <code>sprintf<\/code> fonctionne comme <code>printf<\/code>, mais \u00e9crit dans une cha\u00eene au lieu de le faire \u00e0 l&rsquo;\u00e9cran.<\/p>\n<p>Vous devez <strong>exp\u00e9rimenter<\/strong> l&rsquo;usage de ces fonctions, faire des essais en ex\u00e9cutant la fonction <code>exemple<\/code> et en saisissant des valeurs au clavier (comme par exemple <code>&quot;12&quot;<\/code>, <code>&quot;345rt&quot;<\/code> ou encore <code>&quot;234zz&quot;<\/code>, examiner les r\u00e9sultats pour bien comprendre ce qui se passe. Si vous avez des doutes, posez des questions \u00e0 votre enseignant de TP.<\/p>\n<h3><a id=\"saisir-et-empiler\" class=\"anchor\" aria-hidden=\"true\"><span class=\"octicon octicon-link\"><\/span><\/a>Saisir et empiler<\/h3>\n<p>Vous devez d\u00e9finir une fonction&#8230;<\/p>\n<pre><code class=\"language-c\">void saisEmpile(void);\n<\/code><\/pre>\n<p>&#8230;qui permet de saisir des chaines (quelconques) au clavier, en utilisant la fonction <code>saisir<\/code>, et \u00e0 les empiler dans une pile de capacit\u00e9 <code>CAPA<\/code>, jusqu&rsquo;\u00e0 ce que la cha\u00eene vide soit saisie (par appui sur la touche entr\u00e9e sans avoir rien tap\u00e9 avant), puis qui affiche avec <code>printf<\/code> le contenu de la pile.<\/p>\n<p>Si par exemple l&rsquo;utilisatrice ou l&rsquo;utilisateur fait les saisies suivantes&#8230;<\/p>\n<ul>\n<li>abcd &lt;entr\u00e9e&gt;<\/li>\n<li>56 &lt;entr\u00e9e&gt;<\/li>\n<li>d &lt;entr\u00e9e&gt;<\/li>\n<li>&lt;entr\u00e9e&gt;<\/li>\n<\/ul>\n<p>&#8230;la pile affich\u00e9e doit \u00eatre :<\/p>\n<pre><code class=\"language-plain_text\">#abcd#56#d#\n<\/code><\/pre>\n<p>N&rsquo;oubliez pas :<\/p>\n<ul>\n<li>D&rsquo;initialiser correctement la pile, qui doit contenir un <code>#<\/code> suivi d&rsquo;un marqueur de fin pour pouvoir fonctionner.<\/li>\n<li>De cr\u00e9er un tableau pour r\u00e9cup\u00e9rer les chaines saisies au clavier.<\/li>\n<\/ul>\n<h3><a id=\"calculer\" class=\"anchor\" aria-hidden=\"true\"><span class=\"octicon octicon-link\"><\/span><\/a>Calculer<\/h3>\n<p>Vous devez compl\u00e9ter la fonction suivante pour qu&rsquo;elle permette de r\u00e9aliser un calcul en saisissant des entiers et des op\u00e9rateurs <code>+<\/code>, <code>-<\/code>, <code>*<\/code>, et <code>\/<\/code> en notation polonaise inverse. On <em>suppose<\/em> que la personne utilisatrice saisi uniquement des nombres, des op\u00e9rateurs <code>+<\/code>, <code>-<\/code>, <code>*<\/code>, <code>\/<\/code> et la chaine vide, et saisit un calcul complet, c&rsquo;est \u00e0 dire aboutissant \u00e0 ce qu&rsquo;il reste une seule valeur dans la pile.<\/p>\n<p>N&rsquo;oubliez pas que la pile ne contient que des nombres repr\u00e9sent\u00e9s sous forme de chaines, et aucun op\u00e9rateur. Lorsqu&rsquo;un op\u00e9rateur est saisi, il n&rsquo;est pas empil\u00e9, mais 2 valeurs sont d\u00e9pil\u00e9es, utilis\u00e9es avec l&rsquo;op\u00e9rateur, et le r\u00e9sultat est empil\u00e9.<\/p>\n<pre><code class=\"language-c\">void calcul(void)\n{\n    char pile[CAPA];\n    strcpy(pile,&quot;#&quot;);\n    char buf[CAPA];\n    \n    saisie(buf,10);\n    while(\/* AAAAA *\/)\n    {\n        int c = \/\/ BBBBB\n        if((c=='+')||(c=='-')||(c=='*')||(c=='\/'))\n        {\n            \/\/ CCCCC\n        }\n        empile(pile, buf);\n        saisie(buf, 10);\n    }\n    depile(pile,buf);\n    printf(&quot;R\u00e9sultat : %s\\n&quot;, buf);\n}\n<\/code><\/pre>\n<p>La  condition <code>AAAAA<\/code> doit \u00eatre vraie lorsque la chaine saisie n&rsquo;est pas vide, c&rsquo;est \u00e0 dire lorsqu&rsquo;un op\u00e9rateur ou un nombre a \u00e9t\u00e9 saisi. La saisie d&rsquo;une chaine vide provoque la sortie de la boucle, et donc la r\u00e9cup\u00e9ration du r\u00e9sultat dans la pile et son affichage.<\/p>\n<p>L&rsquo;instruction <code>BBBBB<\/code> place dans la variable <code>c<\/code> le premier caract\u00e8re de la chaine venant d&rsquo;\u00eatre saisie.<\/p>\n<p>Le bloc <code>CCCCC<\/code> est plus complexe et r\u00e9alise les actions suivantes :<\/p>\n<ol>\n<li>D\u00e9piler une cha\u00eene, la convertir en entier.<\/li>\n<li>D\u00e9piler une cha\u00eene, la convertir en entier.<\/li>\n<li>R\u00e9aliser l&rsquo;addition des deux entiers si <code>c<\/code> contient le caract\u00e8re <code>+<\/code>, leur soustraction si <code>c<\/code> contient le caract\u00e8re <code>-<\/code>, etc.<\/li>\n<li>Convertir le r\u00e9sultat en chaine.<\/li>\n<\/ol>\n<p>Vous devez faire des tests intensifs pour v\u00e9rifier le parfait fonctionnement de la &quot;calculatrice&quot; r\u00e9alis\u00e9e.<\/p>\n<h2><a id=\"et-ensuite\" class=\"anchor\" aria-hidden=\"true\"><span class=\"octicon octicon-link\"><\/span><\/a>Et ensuite<\/h2>\n<p>Cette partie est facultative et s&rsquo;adresse aux personnes les plus avanc\u00e9es.<\/p>\n<p>Si vous avez termin\u00e9 les exercices pr\u00e9c\u00e9dents, vous devez r\u00e9fl\u00e9chir \u00e0 une <strong>automatisation<\/strong> du test de la fonction <code>calcul<\/code> avec des sc\u00e9narios de tests pr\u00e9-encod\u00e9s dans des tableaux de cha\u00eenes de caract\u00e8res.<\/p>\n<p>Par exemple, le sc\u00e9nario de calcul donn\u00e9 en exemple plus haut&#8230;<\/p>\n<pre><code class=\"language-plain_text\">12 6 - 5 7 + *\n<\/code><\/pre>\n<p>&#8230;est repr\u00e9sent\u00e9 par le tableau global :<\/p>\n<pre><code class=\"language-c\">char* scenario1[] =\n{\n    &quot;72&quot;, &quot;12&quot;, &quot;6&quot;, &quot;-&quot;, &quot;5&quot;, &quot;7&quot;, &quot;+&quot;, &quot;*&quot;, &quot;&quot;\n};\n<\/code><\/pre>\n<p>La premi\u00e8re chaine repr\u00e9sente le r\u00e9sultat attendu et les suivantes les saisies successives aboutissant \u00e0 ce r\u00e9sultat.<\/p>\n<p>Voici un autre exemple de sc\u00e9nario de test :<\/p>\n<pre><code class=\"language-c\">char* Scenario2[] =\n{\n    &quot;23&quot;, &quot;33&quot;, &quot;5&quot;, &quot;2&quot;, &quot;*&quot;, &quot;-&quot;, &quot;&quot;\n};\n<\/code><\/pre>\n<p>Un <strong>jeu de test<\/strong>, constitu\u00e9 de plusieurs sc\u00e9narios, est repr\u00e9sent\u00e9 par un tableau global :<\/p>\n<pre><code class=\"language-c\">char** Bench[] =\n{\n    Scenario1, Scenario2, NULL\n};\n<\/code><\/pre>\n<p>Les deux fonctions <code>saisie<\/code> et <code>printf<\/code> appel\u00e9es par la fonction <code>calcul<\/code> seront remplac\u00e9es par deux fonctions <code>_saisie<\/code> et <code>_printf<\/code> que vous devrez d\u00e9finir de mani\u00e8re \u00e0 ce que :<\/p>\n<ul>\n<li>les appels \u00e0 <code>_saisie<\/code> simulent des saisies de chaines qui proviendront en fait d&rsquo;un sc\u00e9nario de test,<\/li>\n<li>les appels \u00e0 <code>_printf<\/code> n&rsquo;affichent rien \u00e0 l&rsquo;\u00e9cran (la chaine de formatage sera ignor\u00e9e), mais placent la valeur \u00e0 afficher dans une variable globale o\u00f9 elle pourra \u00eatre r\u00e9cup\u00e9r\u00e9e par la fonction de test pour v\u00e9rifier si elle correspond au r\u00e9sultat pr\u00e9vu par le sc\u00e9nario de test utilis\u00e9.<\/li>\n<\/ul>\n<p>Vous devez d\u00e9clarer d&rsquo;autres variables globales. \u00c0 vous de d\u00e9terminer lesquelles, quels seront leur r\u00f4le, comment la s\u00e9quence de test doit se d\u00e9rouler, et d&rsquo;en d\u00e9duire les impl\u00e9mentations de la fonction de test et des fonctions <code>_saisie<\/code> et <code>_printf<\/code>.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/02\/2-4.png\" alt=\"image-20220225213454169\" \/><\/p>\n<hr \/>\n","protected":false},"excerpt":{"rendered":"<p>Par O. Bailleux, Ma\u00eetre de conf\u00e9rences HDR \u00e0 l&rsquo;universit\u00e9 de Bourgogne. Calculer sans parenth\u00e8ses La prochaine \u00e9valuation de TP sera bas\u00e9e sur ce sujet et pourra rapporter de 0 \u00e0 10 points sur votre note de TP. Pour aborder ce TP, il faut ma\u00eetriser les parties A, C et D du cours. Dans le curriculum [&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-278","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\/278","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=278"}],"version-history":[{"count":1,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/posts\/278\/revisions"}],"predecessor-version":[{"id":279,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/posts\/278\/revisions\/279"}],"wp:attachment":[{"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/media?parent=278"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/categories?post=278"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/tags?post=278"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}