{"id":26,"date":"2021-12-19T11:31:16","date_gmt":"2021-12-19T11:31:16","guid":{"rendered":"https:\/\/9h15.net\/activ\/?p=26"},"modified":"2022-11-28T16:15:19","modified_gmt":"2022-11-28T16:15:19","slug":"c-et-c-partie-a","status":"publish","type":"post","link":"https:\/\/9h15.net\/activ\/c-et-c-partie-a\/","title":{"rendered":"C et C++ partie A"},"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=\"les-bases-du-langage-c\" class=\"anchor\" aria-hidden=\"true\"><\/a>Les bases du langage C<\/h1>\n<p><strong>Fonction principale, variables locales, affichage, instructions de contr\u00f4les, fonctions.<\/strong><\/p>\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-a-dec\" class=\"anchor\" aria-hidden=\"true\"><\/a>Activit\u00e9 de d\u00e9couverte A.dec<\/h2>\n<h3><a id=\"a-dec1-afficher-bonjour\" class=\"anchor\" aria-hidden=\"true\"><\/a>A.dec1 : Afficher \u00ab\u00a0Bonjour\u00a0\u00bb<\/h3>\n<h4><a id=\"pr%C3%A9sentation\" class=\"anchor\" aria-hidden=\"true\"><\/a>Pr\u00e9sentation<\/h4>\n<p>Voici notre premier programme.<\/p>\n<pre><code class=\"language-C\">#include &lt;stdio.h&gt;         \/\/ Ligne A\n\nint main()                 \/\/ Ligne B\n{\n  printf(\"Bonjour\\n\");     \/\/ Ligne C\n  return 0;                \/\/ Ligne D\n}\n<\/code><\/pre>\n<p><strong>La ligne A<\/strong> est une inclusion d&rsquo;un <strong>fichier d\u2019ente\u0302te<\/strong>. Le compilateur en a besoin pour compiler correctement un programme utilisant ma fonction <code>printf<\/code> et \/ ou d&rsquo;autre fonctions standards que nous d\u00e9couvrirons plus tard.<\/p>\n<p>Dans la suite, certaines de ces d\u00e9clarations seront omises mais vous devrez les ajouter au de\u0301but de votre code source pour pouvoir compiler vos programmes.<\/p>\n<p>Il existe de nombreuses documentations en ligne permettant de trouver les d\u00e9clarations n\u00e9cessaires pour utiliser les fonctions standards dont vous aurez besoin, comme par exemple : <a href=\"https:\/\/koor.fr\/C\">https:\/\/koor.fr\/C<\/a>.<\/p>\n<p><strong>La ligne B<\/strong> d\u00e9finit la fonction <code>main<\/code>, qui est aussi appel\u00e9e <strong>fonction principale<\/strong>. Tous nos programmes devront comporter une telle d\u00e9finition de <code>main<\/code> pour \u00eatre ex\u00e9cutables. En effet, l&rsquo;ex\u00e9cution de tout programme en langage C commence par cette fonction.<\/p>\n<p>Les deux accolades { et } encadrent un bloc de code appel\u00e9 le <strong>corps<\/strong> de la fonction <code>main<\/code>. C&rsquo;est l\u00e0 o\u00f9 se trouve le code qui sera ex\u00e9cut\u00e9 lorsque cette fonction sera appel\u00e9e, c&rsquo;est \u00e0 dire au d\u00e9but de l&rsquo;ex\u00e9cution du programme.<\/p>\n<p><strong>La ligne C<\/strong> appelle la fonction standard <code>printf<\/code> qui permet d&rsquo;afficher des informations \u00e0 l&rsquo;\u00e9cran. La cha\u00eene de caract\u00e8res <code>\"Bonjour\\n\"<\/code> est <strong>l&rsquo;argument<\/strong> de cette fonction. Le symbole <code>\\n<\/code> est appel\u00e9 \u00ab\u00a0retour ligne\u00a0\u00bb et permet d&rsquo;indiquer que les affichage suivants (si applicable) doivent commencer au d\u00e9but de la ligne suivante.<\/p>\n<p><strong>La ligne D<\/strong> s&rsquo;ex\u00e9cute juste avant la fin de l&rsquo;ex\u00e9cution du programme et transmet un code au syst\u00e8me d&rsquo;exploitation. Par convention, la valeur 0 indique que l&rsquo;ex\u00e9cution est arriv\u00e9e \u00e0 son terme sans rencontrer d&rsquo;erreur. Si une erreur se produit avant que cette ligne soit atteinte, un code diff\u00e9rent de 0 sera transmis au syst\u00e8me d&rsquo;exploitation.<\/p>\n<h5><a id=\"exercice-de-d%C3%A9couverte-a-dec-x1\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte A.dec.x1<\/h5>\n<p>R\u00e9pondez aux questions suivantes. Essayez d&rsquo;abord de r\u00e9cup\u00e9rer les r\u00e9ponses dans votre m\u00e9moire, et au besoin relisez les explications pr\u00e9c\u00e9dentes pour les retrouver.<\/p>\n<p><strong>Q1.<\/strong> Quel est le r\u00f4le de la directive de compilation <code>#include<\/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>Elle permet d&rsquo;inclure un fichier d&rsquo;ent\u00eate dont le compilateur a besoin pour compiler, notamment, la fonction <code>printf<\/code>.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<p><strong>Q2.<\/strong> Quel est le r\u00f4le de la fonction <code>main<\/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>C&rsquo;est le point d&rsquo;entr\u00e9e du programme, c&rsquo;est \u00e0 dire l\u00e0 o\u00f9 commence son ex\u00e9cution.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<p><strong>Q3.<\/strong> Quelle fonction standard permet de re\u0301aliser des affichages a\u0300 l\u2019e\u0301cran ?<\/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>La fonction <code>printf<\/code>.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<p><strong>Q4.<\/strong> Ou\u0300 va la valeur de retour de la fonction <code>main<\/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>Elle est transmise au syst\u00e8me d&rsquo;exploitation.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<p><strong>Q5.<\/strong> Que repr\u00e9sente le mot <code>int<\/code> situ\u00e9 au d\u00e9but de la ligne B ? Attention, l&rsquo;information n&rsquo;a pas \u00e9t\u00e9 donn\u00e9e. Vous devez essayer la d\u00e9duire vous-m\u00eame.<\/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>Elle indique le type de la valeur retourn\u00e9e par la fonction <code>main<\/code> \u00e0 l&rsquo;issue de son ex\u00e9cution. Plus pr\u00e9cis\u00e9ment, <code>int<\/code> signifie que cette valeur est un entier. En l&rsquo;occurrence, dans notre exemple, c&rsquo;est la valeur 0.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h3><a id=\"a-dec2-compiler-et-ex%C3%A9cuter-votre-premier-programme\" class=\"anchor\" aria-hidden=\"true\"><\/a>A.dec2 : Compiler et ex\u00e9cuter votre premier programme<\/h3>\n<p>Cette activit\u00e9 doit \u00eatre r\u00e9alis\u00e9e lorsque vous disposez d&rsquo;un ordinateur.<\/p>\n<h4><a id=\"m%C3%A9thode-recommand%C3%A9e\" class=\"anchor\" aria-hidden=\"true\"><\/a>M\u00e9thode recommand\u00e9e<\/h4>\n<p>La mani\u00e8re recommand\u00e9e pour vos premiers pas consiste \u00e0 proc\u00e9der en deux \u00e9tapes : l&rsquo;\u00e9dition, puis la compilation.<\/p>\n<h5><a id=\"%C3%89dition-du-code-source\" class=\"anchor\" aria-hidden=\"true\"><\/a>\u00c9dition du code source<\/h5>\n<p>Vous devez utiliser un \u00e9diteur de texte adapt\u00e9 \u00e0 la cr\u00e9ation d&rsquo;un fichier source, comme par exemple <code>Atom<\/code>, <code>Visual Studio Code<\/code>, <code>Sublimetext<\/code>&#8230; Il existe un large choix d&rsquo;\u00e9diteurs gratuits. Enregistrez le code source du programme qui affiche \u00ab\u00a0Bonjour\u00a0\u00bb dans un fichier <code>bonjour.c<\/code>.<\/p>\n<h5><a id=\"compilation\" class=\"anchor\" aria-hidden=\"true\"><\/a>Compilation<\/h5>\n<p>Pour compiler votre programme, il faut qu&rsquo;un compilateur C (et toutes ses d\u00e9pendances) soit install\u00e9 sur votre ordinateur. Si vous travaillez sous <code>Linux<\/code>, le compilateur <code>gcc<\/code> est probablement d\u00e9j\u00e0 install\u00e9 et sinon recherchez sur le WEB ou demandez \u00e0 une personne enseignante ou un ou une condisciple comment l&rsquo;installer. Sous <code>Windows<\/code>, il est possible de lancer une session Linux en ayant install\u00e9 pr\u00e9alablement un composant logiciel appel\u00e9 <code>WSL 2<\/code>. Renseignez vous. Il est aussi possible de faire tourner <code>Linux<\/code> dans une machine virtuelle. Sous <code>MacOS<\/code>, si vous installez l&rsquo;application gratuite <code>Xcode<\/code> avec les outils en ligne de commande, vous aurez acc\u00e8s au compilateur <code>gcc<\/code> et \u00e0 un autre compilateur nomm\u00e9 <code>clang<\/code> qui s&rsquo;utilise de la m\u00eame mani\u00e8re que <code>gcc<\/code>.<\/p>\n<p>Vous devrez ouvrir une console ayant pour r\u00e9pertoire de travail celui dans lequel se trouve votre fichier source <code>bonjour.c<\/code>. La ligne de commande suivante permet de lancer la compilation.<\/p>\n<pre><code class=\"language-plain_text\">gcc bonjour.c  -Wall -o bonjour\n<\/code><\/pre>\n<p>L&rsquo;option <code>-Wall<\/code> demande au compilateur de faire le plus haut niveau de v\u00e9rification du code et d&rsquo;afficher tous les probl\u00e8mes potentiels. Chaque message d&rsquo;avertissement doit \u00eatre pris en consid\u00e9ration et entra\u00eener une correction du code. C&rsquo;est \u00e9videmment valable \u00e9galement pour les messages d&rsquo;erreur.<\/p>\n<blockquote><p>Un message d&rsquo;erreur indique qu&rsquo;un fichier ex\u00e9cutable n&rsquo;a pas pu \u00eatre produit. Un message d&rsquo;avertissement indique qu&rsquo;un ex\u00e9cutable a \u00e9t\u00e9 produit mais qu&rsquo;il y a un probl\u00e8me, comme une ambigu\u00eft\u00e9 dans le code, qui peut entra\u00eener une erreur lors de l&rsquo;ex\u00e9cution.<\/p><\/blockquote>\n<p>L&rsquo;option <code>-o bonjour<\/code> indique que le fichier ex\u00e9cutable sera nomm\u00e9 <code>bonjour<\/code>. On peut \u00e9videmment choisir un autre nom. Il faut \u00e9viter d&rsquo;utiliser le nom d&rsquo;une commande syst\u00e8me tel que <code>test<\/code> (qui est une erreur fr\u00e9quente). Si l&rsquo;option <code>-o<\/code> est absente, l&rsquo;ex\u00e9cutable produit se nommera <code>a.out<\/code>.<\/p>\n<h5><a id=\"ex%C3%A9cution\" class=\"anchor\" aria-hidden=\"true\"><\/a>Ex\u00e9cution<\/h5>\n<p>Le fichier ex\u00e9cutable produit par le compilateur est plac\u00e9 dans le r\u00e9pertoire de travail. Dans notre exemple, c&rsquo;est un fichier nomm\u00e9 <code>bonjour<\/code>. La ligne de commande suivante lance l&rsquo;ex\u00e9cution.<\/p>\n<pre><code class=\"language-plain_text\">.\/bonjour\n<\/code><\/pre>\n<p>Elle demande simplement au syst\u00e8me de lancer l&rsquo;ex\u00e9cution du fichier ex\u00e9cutable <code>bonjour<\/code> situ\u00e9 dans le r\u00e9pertoire de travail.<\/p>\n<h4><a id=\"autres-m%C3%A9thodes\" class=\"anchor\" aria-hidden=\"true\"><\/a>Autres m\u00e9thodes<\/h4>\n<h5><a id=\"utiliser-un-ide-install%C3%A9-sur-votre-ordinateur\" class=\"anchor\" aria-hidden=\"true\"><\/a>Utiliser un IDE install\u00e9 sur votre ordinateur<\/h5>\n<p>Il est possible d&rsquo;utiliser une application appel\u00e9e <code>IDE<\/code> qui permet d&rsquo;\u00e9diter, compiler, ex\u00e9cuter, mettre au point un programme. Une telle application est tr\u00e8s pratique et fait gagner du temps. Mais si vous \u00eates d\u00e9butant, vous devez d\u00e9j\u00e0 ma\u00eetriser le flux de travail en ligne de commande d\u00e9crit pr\u00e9c\u00e9demment.<\/p>\n<h5><a id=\"utiliser-un-ide-en-ligne\" class=\"anchor\" aria-hidden=\"true\"><\/a>Utiliser un IDE en ligne<\/h5>\n<p>Il existe de nombreux environnement de programmation en ligne, payants et gratuits, qui permettent d&rsquo;\u00e9diter, compiler et ex\u00e9cuter des programmes en langage C.<\/p>\n<h3><a id=\"a-dec3-fonction-for-int-variable-locale-affichage\" class=\"anchor\" aria-hidden=\"true\"><\/a>A.dec3 : Fonction, for, int, variable locale, affichage<\/h3>\n<h4><a id=\"pr%C3%A9sentation\" class=\"anchor\" aria-hidden=\"true\"><\/a>Pr\u00e9sentation<\/h4>\n<p>Maintenant que nous savons comment tester nos programmes, nous allons continuer la d\u00e9couverte des notions de bases permettant de faire des choses un peu plus compliqu\u00e9es et int\u00e9ressantes qu&rsquo;afficher \u00ab\u00a0Bonjour\u00a0\u00bb.<\/p>\n<p>Voici un nouveau programme. Pour le tester, n&rsquo;oubliez pas d&rsquo;ajouter au d\u00e9but la ligne <code>#include &lt;stdio.h&gt;<\/code>.<\/p>\n<pre><code class=\"language-C\">void compteur()                    \/\/ Ligne A\n{\n  for(int i = 9; i &gt; 0; i = i-3)   \/\/ Ligne B\n  {\n    printf(\"Valeur : %d\\n\", i);    \/\/ Ligne C\n  }\n}\n\nint main()                      \n{\n  compteur();                      \/\/ Ligne D\n  return 0;\n}\n<\/code><\/pre>\n<p>La premi\u00e8re chose \u00e0 observer est la <strong>structure<\/strong> du programme. <strong>Tout programme est constitu\u00e9 de blocs qui se succ\u00e8dent et\/ou s&rsquo;imbriquent<\/strong>. <strong>Chaque bloc a un r\u00f4le<\/strong>.<\/p>\n<p>Cette structure est tr\u00e8s importante pour comprendre le fonctionnement d&rsquo;un programme et \u00eatre capable de cr\u00e9er de nouveaux programmes.<\/p>\n<p>Ici, nous avons deux blocs qui sont les d\u00e9finitions des fonctions <code>compteur<\/code> et <code>main<\/code>. Le corps de chacune de ces fonctions est \u00e9galement un bloc, d\u00e9limit\u00e9 par des accolades. Ces accolades sont parfaitement align\u00e9es pour faciliter la lisibilit\u00e9 du programme. Cette disposition est appel\u00e9e le <strong>style d&rsquo;indentation Allman<\/strong>. Dans le cadre de cet enseignement, <strong>il vous est demand\u00e9 de respecter ce style<\/strong>, en particulier lorsque vous montrez un programme \u00e0 une personne enseignante.<\/p>\n<p>Pour information, un autre style tr\u00e8s r\u00e9pandu est appel\u00e9 <strong>K &amp; R<\/strong> en r\u00e9f\u00e9rence aux inventeurs du langage C, Brian Kernighan et Dennis Ritchie. Voici la d\u00e9finition de la fonction dans le style K &amp; R.<\/p>\n<pre><code class=\"language-C\">void compteur(){\n  for(int i = 9; i &gt; 0; i = i-3){\n    printf(\"Valeur : %d\\n\", i);       \n  }\n}\n<\/code><\/pre>\n<p>Ce style \u00e9tait parfaitement justifi\u00e9 dans les ann\u00e9es 1970, dans les premiers temps du langage C, parce qu&rsquo;\u00e0 l&rsquo;\u00e9poque, les \u00e9crans ne pouvaient afficher qu&rsquo;un nombre tr\u00e8s limit\u00e9 de lignes de code et que beaucoup de programmeurs n&rsquo;utilisaient pas d&rsquo;\u00e9cran mais un terminal t\u00e9l\u00e9type qui \u00e9tait l&rsquo;association d&rsquo;une imprimante et d&rsquo;un clavier. (L&rsquo;auteur du pr\u00e9sent document a programm\u00e9 avec ce genre d&rsquo;engin dans les ann\u00e9es 1980.)<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2021\/12\/1.jpg\" alt=\"Un t\u00e9l\u00e9type\" \/><\/p>\n<p>Il fallait \u00e9conomiser le papier au d\u00e9triment de la lisibilit\u00e9 du code. De nos jours, beaucoup de d\u00e9veloppeurs utilisent ce style, mais il est banni de cet enseignement au profit du style Allman, plus p\u00e9dagogique.<\/p>\n<p>Voici une mise en \u00e9vidence de la structure en blocs du programme d&rsquo;exemple.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2021\/12\/2.png\" alt=\"image-20211201221010782\" \/><\/p>\n<p>Commen\u00e7ons par regarder la fonction <code>main<\/code>. Son r\u00f4le est d&rsquo;appeler la fonction <code>compteur<\/code>. On aurait pu mettre le code de la fonction <code>compteur<\/code> dans la fonction <code>main<\/code>, mais le but ici est d&rsquo;illustrer l&rsquo;appel d&rsquo;une fonction ne retournant aucune valeur et n&rsquo;ayant aucun param\u00e8tre, c&rsquo;est \u00e0 dire n&rsquo;acceptant aucun argument.<\/p>\n<p>Int\u00e9ressons-nous maintenant \u00e0 la fonction <code>compteur<\/code>.<\/p>\n<pre><code class=\"language-C\">void compteur()                    \/\/ Ligne A\n{\n  for(int i = 9; i &gt; 0; i = i-3)   \/\/ Ligne B\n  {\n    printf(\"Valeur : %d\\n\", i);    \/\/ Ligne C\n  }\n}\n<\/code><\/pre>\n<p><strong>En ligne A<\/strong>, le mot cl\u00e9 <code>void<\/code> indique que la fonction ne retourne rien. Une telle fonction peut \u00eatre appel\u00e9e <strong>proc\u00e9dure<\/strong>. Les parenth\u00e8ses vides apr\u00e8s le nom de la fonction indique qu&rsquo;elle n&rsquo;a aucun param\u00e8tre.<\/p>\n<p><strong>La ligne B<\/strong> d\u00e9finit une <strong>boucle<\/strong> \u00e0 l&rsquo;aide de l&rsquo;instruction <code>for<\/code>.<\/p>\n<p>Cette boucle est contr\u00f4l\u00e9e par une variable <code>i<\/code> qui est d\u00e9clar\u00e9e et initialis\u00e9e par la notation <code>int i = 9<\/code>. Il s&rsquo;agit d&rsquo;une <strong>variable locale<\/strong> qui n&rsquo;existe que pendant l&rsquo;ex\u00e9cution de la boucle. L&rsquo;initialisation s&rsquo;effectue, comme son nom l&rsquo;indique, une seule fois.<\/p>\n<p>L&rsquo;expression <code>i &gt; 0<\/code> est <strong>l&rsquo;expression de contr\u00f4le<\/strong> de la boucle. Tant que sa valeur est vraie, la boucle continue de s&rsquo;ex\u00e9cuter. Cette condition est test\u00e9e avant chaque ex\u00e9cution du corps de la boucle, qui est le bloc imm\u00e9diatement en dessous.<\/p>\n<p>Enfin, l&rsquo;expression <code>i = i-3<\/code> est <strong>la mise \u00e0 jour de la boucle<\/strong>. Elle est ex\u00e9cut\u00e9e apr\u00e8s chaque <strong>it\u00e9ration<\/strong>, c&rsquo;est \u00e0 dire chaque ex\u00e9cution du corps de la boucle.<\/p>\n<p><strong>La ligne C<\/strong> est dans le corps de la boucle. Elle sera ex\u00e9cut\u00e9e trois fois :<\/p>\n<ul>\n<li>une fois avec <code>i<\/code> \u00e9gal \u00e0 9,<\/li>\n<li>une fois avec <code>i<\/code> \u00e9gal \u00e0 6,<\/li>\n<li>et une fois avec <code>i<\/code> \u00e9gal \u00e0 3.<\/li>\n<\/ul>\n<p>\u00c0 l&rsquo;issue de ces trois ex\u00e9cutions, la valeur de <code>i<\/code> est 0 et la condition de contr\u00f4le devient fausse. L&rsquo;ex\u00e9cution de la boucle s&rsquo;arr\u00eate.<\/p>\n<p>La fonction <code>printf<\/code> est utilis\u00e9e ici pour afficher la valeur de la variable <code>i<\/code>. On lui transmet deux arguments :<\/p>\n<ul>\n<li>une cha\u00eene de formatage qui indique dans quelle format afficher la donn\u00e9e,<\/li>\n<li>et la donn\u00e9e \u00e0 afficher.<\/li>\n<\/ul>\n<p>Ici, la donn\u00e9e est de type <code>int<\/code>. Ce type repr\u00e9sente des entiers sign\u00e9s, c&rsquo;est \u00e0 dire pouvant prendre des valeurs n\u00e9gatives ou positives. Nous reviendrons plus tard sur les bornes de ces valeurs. la notation <code>%d<\/code> dans la cha\u00eene de formatage indique que l&rsquo;affichage de cet entier devra \u00eatre r\u00e9alis\u00e9 en base 10.<\/p>\n<p>A l&rsquo;ex\u00e9cution, nous aurons l&rsquo;affichage suivant :<\/p>\n<pre><code class=\"language-plain_text\">Valeur : 9\nValeur : 6\nValeur : 3\n<\/code><\/pre>\n<h5><a id=\"exercice-de-d%C3%A9couverte-a-dec-x2\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte A.dec.x2<\/h5>\n<p><strong>Q1.<\/strong> Dans la fonction compteur, si on initialise i \u00e0 0 plut\u00f4t que 9, que se passera-t-il \u00e0 l&rsquo;ex\u00e9cution ? (Vous devez r\u00e9pondre sans ex\u00e9cuter le programme sur machine) ?<\/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>La condition de contr\u00f4le \u00e9tant fausse d\u00e8s le d\u00e9part, le corps de la boucle ne s&rsquo;ex\u00e9cute pas et il n&rsquo;y a aucun affichage.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<p><strong>Q2.<\/strong> On remplace la fonction compteur par cette variante.<\/p>\n<pre><code class=\"language-C\">void compteur()                    \/\/ Ligne A\n{\n  for(int i = 9; i &gt; 0; i = i+3)   \/\/ Ligne B\n  {\n    printf(\"Valeur : %d\\n\", i);    \/\/ Ligne C\n  }\n}\n<\/code><\/pre>\n<p>Que se passe-t-il \u00e0 l&rsquo;ex\u00e9cution ?<\/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>Si vous avez r\u00e9pondu que le programme boucle ind\u00e9finiment en affichant tous les multiples de 3 \u00e0 partir de 9, alors vous avez bien compris le fonctionnement d&rsquo;une boucle <code>for<\/code>.<\/p>\n<p>La v\u00e9ritable r\u00e9ponse est que le programme va finir par s&rsquo;arr\u00eater. En effet, les donn\u00e9es de type <code>int<\/code> sont repr\u00e9sent\u00e9es par des mots binaires de taille finie. Dans les architectures actuelles, sur 32 bits. La moiti\u00e9 de ces mots binaires repr\u00e9sentent des entiers positifs et l&rsquo;autre moiti\u00e9 des entiers n\u00e9gatifs. \u00c0 force d&rsquo;augmenter la valeur de i, on va d\u00e9passer le plus grand entier positif repr\u00e9sentable et produire une valeur n\u00e9gative. Cela s&rsquo;appelle un <strong>d\u00e9bordement<\/strong>. La condition de contr\u00f4le deviendra alors fausse.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h3><a id=\"a-dec4-while-modulo-rand-bool%C3%A9ens-valeur-de-retour\" class=\"anchor\" aria-hidden=\"true\"><\/a>A.dec4 : While, modulo, rand, Bool\u00e9ens, valeur de retour<\/h3>\n<h4><a id=\"pr%C3%A9sentation\" class=\"anchor\" aria-hidden=\"true\"><\/a>Pr\u00e9sentation<\/h4>\n<p>Un nouveau programme va nous permettre de d\u00e9couvrir ou red\u00e9couvrir de nouvelles instructions et une fonction standard tr\u00e8s pratique pour produire des nombres pseudo-al\u00e9atoires.<\/p>\n<pre><code class=\"language-C\">int jusquaPile()                   \/\/ Ligne A\n{\n  int nbEssais = 1;                \/\/ Ligne B\n  while(rand() % 2)                 \/\/ Ligne C\n  {\n    nbEssais = nbEssais + 1;       \/\/ Ligne D\n  }\n  return nbEssais;                 \/\/ Ligne E\n}\n\nint main()                      \n{\n  srand((unsigned)time(NULL));     \/\/ Ligne F\n  printf(\"%d\\n\", jusquaPile());    \/\/ Ligne G                   \n  return 0;\n}\n<\/code><\/pre>\n<p>Chaque ligne introduit un concept tr\u00e8s utile que vous devrez savoir r\u00e9utiliser plus tard.<\/p>\n<p><strong>La ligne A<\/strong> d\u00e9finit une fonction sans param\u00e8tre mais qui retourne un entier. Le r\u00f4le de cette fonction est de simuler des tirages \u00e0 pile ou face jusqu&rsquo;\u00e0 ce que pile soit tir\u00e9, puis de retourner le nombre de tirages en comptabilisant celui qui a produit pile.<\/p>\n<p><strong>La ligne B<\/strong> d\u00e9clare une variable nomm\u00e9e <code>nbEssais<\/code> et l&rsquo;initialise avec la valeur 1. Cette variable est locale \u00e0 la fonction <code>jusquaPile<\/code>.<\/p>\n<p><strong>La ligne C<\/strong> d\u00e9finit une <strong>boucle while<\/strong>. Le corps de cette boucle s&rsquo;ex\u00e9cutera tant que la condition de contr\u00f4le sera vraie. Cette condition est <code>rand() % 2<\/code>, ce qui requiert quelques explications.<\/p>\n<ul>\n<li>Il existe une fonction standard <code>rand<\/code> sans param\u00e8tre qui produit un nombre al\u00e9atoire compris entre 0 et une tr\u00e8s grande valeur, qui n&rsquo;est pas tr\u00e8s importante ici.<\/li>\n<li>L&rsquo;op\u00e9rateur <code>%<\/code> permet de calculer un modulo, c&rsquo;est \u00e0 dire le reste d&rsquo;une division enti\u00e8re. Si l&rsquo;appel retourne une valeur paire, alors <code>rand()%2<\/code> vaut 0, sinon <code>rand()%2<\/code> vaut 1. Chaque cas se produit avec une probabilit\u00e9 1\/2, ce qui permet de simuler un tirage \u00e0 pile ou face.<\/li>\n<li>Le langage C repr\u00e9sente les valeurs Bool\u00e9ennes vrai et faux par des entiers, avec la convention suivante : 0 repr\u00e9sente faux, et toute autre valeur, comme par exemple 1, repr\u00e9sente vrai.<\/li>\n<\/ul>\n<p>Donc \u00e0 chaque fois qu&rsquo;elle est \u00e9valu\u00e9e, la condition de contr\u00f4le de la boucle a une chance sur deux d&rsquo;\u00eatre vraie.<\/p>\n<p><strong>La ligne D<\/strong> s&rsquo;ex\u00e9cute \u00e0 chaque fois que l&rsquo;\u00e9valuation de la condition de contr\u00f4le produit la valeur vrai, ce qui <strong>par convention<\/strong> correspond \u00e0 un tirage de la valeur <strong>pile<\/strong>. Donc si face est tir\u00e9, le corps de la boucle s&rsquo;ex\u00e9cute et la variable <code>nbEssais<\/code> est incr\u00e9ment\u00e9e.<\/p>\n<p><strong>La ligne E<\/strong> s&rsquo;ex\u00e9cute quand la boucle a termin\u00e9 son ex\u00e9cution, donc apr\u00e8s un nombre d&rsquo;it\u00e9rations \u00e9gal au nombre de faces tir\u00e9s avant le premier tirage de pile. Si face est tir\u00e9e au premier essai (<code>rand()%2<\/code> vaut 0) alors le corps de la boucle ne s&rsquo;ex\u00e9cute pas et la valeur de la variable <code>nbEssais<\/code> sera 1. Sinon se sera 1 plus le nombre de faces tir\u00e9s avant la premi\u00e8re valeur pile. L&rsquo;instruction <code>return<\/code> demande \u00e0 la fonction de retourner cette valeur.<\/p>\n<p>Examinons maintenant la fonction <code>main<\/code>.<\/p>\n<p><strong>La ligne F<\/strong> est facultative. Elle permet d&rsquo;initialiser le germe du g\u00e9n\u00e9rateur pseudoal\u00e9atoire avec le nombre de secondes \u00e9coul\u00e9es depuis le premier janvier 1970. Si on omet cette ligne, le g\u00e9n\u00e9rateur produira la m\u00eame s\u00e9quence de nombres \u00e0 chaque ex\u00e9cution du programme. Le r\u00e9sultat sera reproductible, mais peu r\u00e9aliste.<\/p>\n<p><strong>La ligne G<\/strong> appelle la fonction <code>jusquaPile<\/code> et affiche sa valeur de retour.<\/p>\n<p>Attention, pour que le programme puisse \u00eatre compil\u00e9 et ex\u00e9cut\u00e9, vous devez ajouter les lignes suivantes au d\u00e9but du fichier source.<\/p>\n<pre><code class=\"language-C\">#include &lt;stdio.h&gt;\n#include &lt;stdlib.h&gt;\n#include &lt;time.h&gt;\n<\/code><\/pre>\n<p>En g\u00e9n\u00e9ral, dans la suite du cours, les fichiers d&rsquo;ent\u00eate \u00e0 inclure ne seront pas donn\u00e9es dans les exemples, mais vous devrez les ajouter pour pouvoir tester ces exemples sur machine.<\/p>\n<h5><a id=\"exercice-de-d%C3%A9couverte-a-dec-x3\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte A.dec.x3<\/h5>\n<p>Au lieu de retourner le nombre de tirages r\u00e9alis\u00e9s pour obtenir pile dans une simulation de tirages \u00e0 pile ou face, on souhaite retourner le nombre de tirages r\u00e9alis\u00e9s pour obtenir un 6 dans une simulation de lanc\u00e9s d&rsquo;un d\u00e9 \u00e0 6 faces. Modifiez le programme en cons\u00e9quence.<\/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 suffit de remplacer la condition <code>rand()%2<\/code> par <code>rand()%6<\/code>. Les r\u00e9sultats possibles seront les entiers 0, 1, 2, 3, 4 et 5. On adopte la convention que la valeur 0 repr\u00e9sente le tirage au d\u00e9 de la valeur 6, ce qui n&rsquo;affecte pas le r\u00e9sultat puisque cette valeur 0 \u00e0 une chance sur 6 d&rsquo;\u00eatre produite.<\/p>\n<p>Mais si vous tenez \u00e0 simuler les tirages des valeurs 1 \u00e0 6, alors vous pouvez r\u00e9\u00e9crire la fonction comme ceci.<\/p>\n<pre><code class=\"language-C\">int jusquaSix()     \n{\n  int nbEssais = 1; \n  int tirage = (rand() % 6) + 1;    \/\/ Ligne X\n  while(tirage != 6)              \n  {\n    nbEssais = nbEssais + 1;\n    tirage = (rand() % 6) + 1;      \/\/ Ligne Y\n  }\n  return nbEssais;  \n}\n<\/code><\/pre>\n<p>Dans cette version, la variable <code>tirage<\/code> re\u00e7oit une valeur comprise entre 1 et 6 \u00e0 chaque ex\u00e9cution des lignes X et Y. Mais comme le g\u00e9n\u00e9rateur pseudoal\u00e9atoire est non biais\u00e9, cela ne change rien \u00e0 la distribution statistique des r\u00e9sultats.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h5><a id=\"exercice-de-d%C3%A9couverte-a-dec-x4\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte A.dec.x4<\/h5>\n<p>Compl\u00e9tez la d\u00e9finition suivante de mani\u00e8re a ce que l&rsquo;ex\u00e9cution de la fonction <code>jusquaPile<\/code> ait exactement le m\u00eame effet que la version initiale.<\/p>\n<pre><code class=\"language-C\">int jusquaPile()\n{\n  int nbEssais = 1;\n  for(;                 ;                );\n  return nbEssais;\n}\n<\/code><\/pre>\n<p>Il n&rsquo;y a pas d&rsquo;initialisation dans la d\u00e9finition de la boucle <code>for<\/code> (parce qu&rsquo;elle est faite avant), mais uniquement la condition de contr\u00f4le et la mise \u00e0 jour.<\/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 jusquaPile()\n{\n  int nbEssais = 1;\n  for(; rand()%2; nbEssais = nbEssais + 1);\n  return nbEssais;\n}\n<\/code><\/pre>\n<p>Il est possible de remplacer <code>nbEssais = nbEssais + 1<\/code> par <code>nbEssais++<\/code>.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h3><a id=\"a-dec5-if-else-type-double-fonctions-avec-param%C3%A8tres-exit\" class=\"anchor\" aria-hidden=\"true\"><\/a>A.dec5 : If, else, type double, fonctions avec param\u00e8tres, exit<\/h3>\n<h4><a id=\"pr%C3%A9sentation\" class=\"anchor\" aria-hidden=\"true\"><\/a>Pr\u00e9sentation<\/h4>\n<p>Nous allons maintenant travailler sur un programme un peu plus complexe qui calcule combien il faut, <strong>en moyenne<\/strong>, de tirages \u00e0 pile ou face pour obtenir la valeur pile. Pour calculer cette moyenne, il faut r\u00e9aliser un certain nombre d&rsquo;essais. On conserve la fonction <code>jusquaPile<\/code> de la partie pr\u00e9c\u00e9dente, dont voici la d\u00e9finition, pour m\u00e9moire.<\/p>\n<pre><code class=\"language-C\">int jusquaPile()                   \n{\n  int nbEssais = 1;   \n  while(rand() % 2)  \n  {\n    nbEssais = nbEssais + 1; \n  }\n  return nbEssais;      \n}\n<\/code><\/pre>\n<p>On d\u00e9finit une nouvelle fonction qui va appeler <code>jusquaPile<\/code> un nombre de fois d\u00e9termin\u00e9 par un param\u00e8tre nomm\u00e9 <code>nombreEssais<\/code> et calculer la moyenne des valeurs retourn\u00e9es par ces appels. Voici le d\u00e9tail de cette nouvelle fonction.<\/p>\n<pre><code class=\"language-C\">double moyenneJusquaPile(int nombreEssais)\n{\n  if(nombreEssais &lt;= 0)                     \/\/ Ligne A\n  {\n    printf(\"Nombre d'essais incorrect\\n\");\n    exit(1);                                \/\/ ligne B\n  }\n  else\n  {\n    double somme = 0.0;                     \/\/ Ligne C\n    for(int i=0; i &lt; nombreEssais; i++)\n    {\n      somme = somme + jusquaPile();\n    }\n    return somme \/ nombreEssais;            \/\/ Ligne D\n  }\n}\n<\/code><\/pre>\n<p>On voit appara\u00eetre <strong>en ligne A<\/strong> une alternative <code>if<\/code> &#8230; <code>else<\/code>. Son r\u00f4le doit vous parapitre assez \u00e9vident si vous avez les pr\u00e9requis pour suivre cet enseignement, c&rsquo;est \u00e0 dire une certaine pratique de la programmation proc\u00e9durale ou objet.<\/p>\n<p><strong>En ligne B<\/strong> il y a du nouveau. L&rsquo;instruction <code>exit<\/code> permet de quitter imm\u00e9diatement le programme en indiquant la valeur \u00e0 retourner au syst\u00e8me d&rsquo;exploitation qui se substitue \u00e0 celle retourn\u00e9e par la fonction <code>main<\/code>. On l&rsquo;utilise essentiellement en cas d&rsquo;erreur ne pouvant \u00eatre g\u00e9r\u00e9e autrement que par un arr\u00eat du programme.<\/p>\n<p>Le calcul demand\u00e9 \u00e0 la fonction est r\u00e9alis\u00e9 dans le bloc <code>else<\/code> de l&rsquo;alternative.<\/p>\n<p><strong>En ligne C<\/strong>, une variable locale nomm\u00e9e <code>somme<\/code> est d\u00e9clar\u00e9e et initialis\u00e9e. Cette variable est de type <code>double<\/code> et pourra contenir des valeurs non enti\u00e8res. Les valeurs qui lui seront ajout\u00e9es sont les r\u00e9sultats des appels \u00e0 la fonction <code>jusquaPile<\/code>, qui sont de type <code>int<\/code>. On peut ajouter un <code>int<\/code> \u00e0 un <code>double<\/code> et le r\u00e9sultat est un <code>double<\/code>.<\/p>\n<p>Le r\u00f4le de la boucle <code>for<\/code> est \u00e9vident.<\/p>\n<p><strong>La ligne D<\/strong> demande \u00e0 la fonction de retourner le rapport de la somme des valeurs produites par chaque essai sur le nombre d&rsquo;essais. On divise donc un <code>double<\/code> par un entier, ce qui a pour r\u00e9sultat une valeur de type <code>double<\/code>.<\/p>\n<p>Pour compl\u00e9ter notre programme et tester la fonction <code>moyenneJusquaPile<\/code>, il nous faut une fonction <code>main<\/code>. la voici.<\/p>\n<pre><code class=\"language-C\">int main()                      \n{\n  srand((unsigned)time(NULL));\n  printf(\"%.02f\\n\", moyenneJusquaPile(1000000));\n  return 0;\n}\n<\/code><\/pre>\n<p>La nouveaut\u00e9 ici est le format d&rsquo;affichage <code>%02f<\/code> de printf, qui affiche une valeur de type <code>double<\/code> avec 2 chiffres apr\u00e8s le point d\u00e9cimal. On peut bien s\u00fbr modifier ce nombre de chiffres apr\u00e8s la virgule.<\/p>\n<p>Avec un million d&rsquo;essais, on obtient la valeur 2.00, soit en moyenne deux tirages pour obtenir pile.<\/p>\n<h5><a id=\"exercice-de-d%C3%A9couverte-a-dec-x5\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte A.dec.x5<\/h5>\n<p>L&rsquo;entreprise \u00c9lo\u00efs et Morlocks a \u00e9t\u00e9 pirat\u00e9e et les lignes de code suivantes ont \u00e9t\u00e9 introduites au d\u00e9but de la d\u00e9finition d&rsquo;une fonction nomm\u00e9e <code>updateRound<\/code> dans le code source de l&rsquo;application commercialis\u00e9e par l&rsquo;entreprise.<\/p>\n<pre><code class=\"language-C\">if( (rand() % 10000) == 0 )\n{\n  exit(1);\n}\n<\/code><\/pre>\n<p>L&rsquo;application ex\u00e9cute la fonction <code>updateRound<\/code> environ une fois par heure. Lors des tests, aucune anomalie n&rsquo;est constat\u00e9e. La version modifi\u00e9e est remplac\u00e9e par l&rsquo;ancienne version chez 1000 clients. Que faut-il craindre 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 chaque ex\u00e9cution de la fonction <code>updateRound<\/code>, il y a une chance sur 10000 que l&rsquo;application s&rsquo;arr\u00eate. La situation ne s&rsquo;est jamais produite durant les tests, mais occasionnellement, un client verra son application s&rsquo;arr\u00eater.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h5><a id=\"exercice-de-d%C3%A9couverte-a-dec-x6\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte A.dec.x6<\/h5>\n<p>Le directeur des \u00e9tablissements \u00c9lo\u00efs et Morlocks ex\u00e9cute le programme suivant.<\/p>\n<pre><code class=\"language-C\">int main()\n{\n  for(int i=0; i&lt;10; i++)\n  {\n    srand((unsigned)time(NULL));\n    printf(\"%d \", rand() % 100);   \n  }\n  printf(\"\\n\");\n}\n<\/code><\/pre>\n<p>Il constate que le m\u00eame nombre s&rsquo;affiche 10 fois \u00e0 l&rsquo;\u00e9cran alors qu&rsquo;il pensait que la probabilit\u00e9 d&rsquo;un tel \u00e9v\u00e8nement \u00e9tait extr\u00eamement faible. Que s&rsquo;est-il pass\u00e9 ? Comment corriger le probl\u00e8me ?<\/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>L&rsquo;appel \u00e0 <code>srand<\/code> initialise le germe du g\u00e9n\u00e9rateur qui d\u00e9termine la s\u00e9quence des nombres produits par <code>rand<\/code>. Dans le code ci-dessus, l&rsquo;appel \u00e0 <code>srand<\/code> est r\u00e9alis\u00e9 en utilisant comme germe une valeur qui change toutes les secondes. (Pour m\u00e9moire, <code>time(NULL))<\/code> retourne le nombre de secondes \u00e9coul\u00e9es depuis le premier janvier 1970. Lorsque le directeur a ex\u00e9cut\u00e9 le programme, les 10 appels \u00e0 <code>srand<\/code> ont eu lieu pendant la m\u00eame seconde, et donc avec le m\u00eame germe. L&rsquo;appel \u00e0 <code>rand<\/code> a donc retourn\u00e9 10 fois la m\u00eame valeur.<\/p>\n<p>Pour \u00e9viter cela, il faut appeler <code>srand<\/code> <strong>une seule fois<\/strong>, au d\u00e9but de la fonction <code>main<\/code>.<\/p>\n<p><\/div>\n\t\t\t<\/div>\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<h2><a id=\"activit%C3%A9-d-entra%C3%AEnement-a-ent\" class=\"anchor\" aria-hidden=\"true\"><\/a>Activit\u00e9 d&rsquo;entra\u00eenement A.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-a-ent1\" class=\"anchor\" aria-hidden=\"true\"><\/a>It\u00e9ration A.ent1<\/h3>\n<h4><a id=\"exercice-d-entrainement-a-ent1-1\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement A.ent1.1<\/h4>\n<p>R\u00e9alisez une fonction <code>somme<\/code> ayant un param\u00e8tre <code>n<\/code> de type <code>int<\/code> et retournant un entier \u00e9gal \u00e0 la somme de tous les entiers compris entre 1 et <code>n<\/code>. Par exemple, l&rsquo;appel <code>somme(3)<\/code> devra retourner la valeur 6, c&rsquo;est \u00e0 dire 1 + 2 + 3. R\u00e9alisez une fonction <code>main<\/code> qui calcule et affiche la somme des entiers compris entre 1 et 100 en utilisant la fonction <code>somme<\/code>.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice 1<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>Voici une partie de la d\u00e9finition de <code>somme<\/code>, \u00e0 compl\u00e9ter.<\/p>\n<pre><code class=\"language-C\">int somme(int n)\n{\n  int total = 0;\n  for(                                   )\n  {\n    \n  }\n  return total;\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 somme(int n)\n{\n  int total = 0;\n  for(int i=0; i &lt;= n; i++)\n  {\n    total = total + i;\n  }\n  return total;\n}\n<\/code><\/pre>\n<pre><code class=\"language-C\">int main()\n{\n  printf(\"%d\\n\", somme(100));\n  return 0;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h4><a id=\"exercice-d-entrainement-a-ent1-2\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement A.ent1.2<\/h4>\n<p>R\u00e9alisez une fonction <code>void printMotif(int n)<\/code> qui affiche le motif suivant dont la largeur et la hauteur doivent \u00eatre de 2n &#8211; 1 caract\u00e8res. L&rsquo;exemple est donn\u00e9 pour n \u00e9gal \u00e0 6. Vous pouvez ajouter certaines fonctions, et c&rsquo;est m\u00eame conseill\u00e9 pour rendre votre code plus lisible.<\/p>\n<pre><code class=\"language-plain_text\">A A A A A A\nA         A\nA         A\nA         A\nA         A\nA A A A A A\n<\/code><\/pre>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice 1<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-C\">\/\/ Affiche n caract\u00e8re 'A' s\u00e9par\u00e9s par des espaces\nvoid printLine1(int n)\n{\n  for(int i=0; i&lt;n; i++)\n  {\n    \/\/ \u00c0 compl\u00e9ter\n  }\n}\n\n\/\/ affiche 2 caract\u00e8res 'A' s\u00e9par\u00e9s par 2n-4 espaces\nvoid printLine2(int n)\n{\n  \/\/ \u00c0 compl\u00e9ter\n}\n  \nvoid printMotif(int n)\n{\n  printLine1();\n  \/\/ \u00c0 compl\u00e9ter\n  printLine1();\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\">Indice 2<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-C\">\/\/ Affiche n A s\u00e9par\u00e9s par des espaces\nvoid printLine1(int n)\n{\n  for(int i=0; i&lt;n; i++)\n  {\n    printf(\"A \");\n  }\n  printf(\"\\n\");\n}\n\n\/\/ affiche 2 A s\u00e9par\u00e9s par 2n-4 espaces\nvoid printLine2(int n)\n{\n  \/\/ \u00c0 compl\u00e9ter\n}\n  \nvoid printMotif(int n)\n{\n  printLine1();\n  for(int i=0; i&lt;(n-2); i++)\n  {\n    \/\/ \u00c0 compl\u00e9ter\n  }\n  printLine1();\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\">\/\/ Affiche n A s\u00e9par\u00e9s par des espaces\nvoid printLine1(int n)\n{\n  for(int i=0; i&lt;n; i++)\n  {\n    printf(\"A \");\n  }\n  printf(\"\\n\");\n}\n\n\/\/ affiche 2 A s\u00e9par\u00e9s par 2n-4 espaces\nvoid printLine2(int n)\n{\n  printf(\"A \");\n  for(int i=0; i&lt;((2*n)-4); i++)\n  {\n    printf(\" \");\n  }\n  printf(\"A\\n\");\n}\n  \nvoid printMotif(int n)\n{\n  printLine1(n);\n  for(int i=0; i&lt;(n-2); i++)\n  {\n    printLine2(n);\n  }\n  printLine1(n);\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h4><a id=\"exercice-d-entrainement-a-ent1-3\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement A.ent1.3<\/h4>\n<p>Soit la fonction suivante.<\/p>\n<pre><code class=\"language-C\">void f(int k)\n{\n  for(int i=k; i &gt;= 0; i--)\n  {\n    printf(\"%d \",i);\n  }\n  printf(\"\\n\");\n}\n<\/code><\/pre>\n<p>Donnez les affichages r\u00e9alis\u00e9s par <code>f(5)<\/code> et r\u00e9\u00e9crivez la fonction <code>f<\/code> sans utiliser de <code>for<\/code> mais en utilisant un <code>while<\/code>. La nouvelle fonction doit se comporter en tous points comme l&rsquo;ancienne.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice 1<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>L&rsquo;affichage est :<\/p>\n<pre><code class=\"language-plain_text\">5 4 3 2 1 0 \n<\/code><\/pre>\n<p>Voici un squelette \u00e0 compl\u00e9ter de la nouvelle fonction.<\/p>\n<pre><code class=\"language-C\">void f(int k)\n{\n  \/\/ Initialisation \u00e0 compl\u00e9ter\n  while(                   )\n  {\n    printf(\"%d \",i);\n    \/\/ \u00c0 compl\u00e9ter\n  }\n  printf(\"\\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\">Solution<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-C\">void f(int k)\n{\n  int i = k;\n  while(i &gt;=0)\n  {\n    printf(\"%d \",i);\n    i--;\n  }\n  printf(\"\\n\");\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h3><a id=\"it%C3%A9ration-a-ent2\" class=\"anchor\" aria-hidden=\"true\"><\/a>It\u00e9ration A.ent2<\/h3>\n<h4><a id=\"exercice-d-entrainement-a-ent2-1\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement A.ent2.1<\/h4>\n<p>R\u00e9alisez une fonction <code>int mul(int a, int b)<\/code> retournant le produit de tous les nombres compris entre <code>a<\/code> (inclus) et <code>b<\/code> (inclus). R\u00e9alisez une fonction <code>main<\/code> qui calcule et affiche le produit des entiers compris entre 3 et 7 des en utilisant la fonction <code>mul<\/code>.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice 1<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>Voici une partie de la d\u00e9finition de <code>mul<\/code>, \u00e0 compl\u00e9ter.<\/p>\n<pre><code class=\"language-C\">int mul(int a, int b)\n{\n  int produit = 1;\n  for(                                   )\n  {\n    \n  }\n  return produit;\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 mul(int a, int b)\n{\n  int produit = 1;\n  for(int i=a; i &lt;= b; i++)\n  {\n    produit = produit * i;\n  }\n  return produit;\n}\n<\/code><\/pre>\n<pre><code class=\"language-C\">int main()\n{\n  printf(\"%d\\n\", mul(3, 7));\n  return 0;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h4><a id=\"exercice-d-entrainement-a-ent2-2\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement A.ent2.2<\/h4>\n<p>R\u00e9alisez une fonction <code>void printMotif(int n)<\/code> qui affiche le motif suivant dont la largeur \u00e0 la base doit \u00eatre de n caract\u00e8res. On suppose que n est impair. L&rsquo;exemple est donn\u00e9 pour n \u00e9gal \u00e0 7. Vous pouvez ajouter certaines fonctions, et c&rsquo;est m\u00eame conseill\u00e9 pour rendre votre code plus lisible. La cl\u00e9 du succ\u00e8s est de d\u00e9composer le traitement \u00e0 r\u00e9aliser en plusieurs \u00e9tapes.<\/p>\n<pre><code class=\"language-plain_text\">   A  \n  AAA\n AAAAA\nAAAAAAA\n<\/code><\/pre>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice 1<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-C\">\/\/ Affiche n espaces suivis de m caract\u00e8res 'A' \nvoid printLine(int n, int m)\n{\n  for(int i=0; i&lt;n; i++)\n  {\n    \/\/ \u00c0 compl\u00e9ter\n  }\n  \/\/ \u00c0 compl\u00e9ter\n}\n \nvoid printMotif(int n)\n{\n  \/\/ \u00c0 compl\u00e9ter\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\">Indice 2<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-C\">\/\/ Affiche n espaces suivis de m caract\u00e8res 'A' \nvoid printLine(int n, int m)\n{\n  for(int i=0; i&lt;n; i++)\n  {\n    printf(\" \");\n  }\n  for(int i=0; i&lt;n; i++)\n  {\n    printf(\"A\");\n  }\n  printf(\"\\n\");\n}\n \nvoid printMotif(int n)\n{\n  int k = (n+1)\/2; \/\/ Nombre de ligne \u00e0 afficher\n  int m = 1;   \/\/ Nombre de A par ligne\n  for(int i=k-1; i&lt;=0; i--)\n  {\n    \/\/ \u00c0 compl\u00e9ter\n  }\n}\n<\/code><\/pre>\n<p>On num\u00e9rote les lignes de k-1 \u00e0 0 en partant du sommet du triangle, c&rsquo;est \u00e0 dire de la premi\u00e8re ligne \u00e0 afficher. Combien faut-il d&rsquo;espaces au d\u00e9but de la ligne k ? Il faut un caract\u00e8re &lsquo;A&rsquo; sur la premi\u00e8re ligne. De combien le nombre de &lsquo;A&rsquo; \u00e0 afficher augmente d&rsquo;une ligne \u00e0 la suivante ? En r\u00e9pondant \u00e0 toutes ces questions, et en faisant des essais et erreurs, tentez de trouver la solution.<\/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\">\/\/ Affiche n espaces suivis de m caract\u00e8res 'A' \nvoid printLine(int n, int m)\n{\n  for(int i=0; i&lt;n; i++)\n  {\n    printf(\" \");\n  }\n  for(int i=0; i&lt;m; i++)\n  {\n    printf(\"A\");\n  }\n  printf(\"\\n\");\n}\n \nvoid printMotif(int n)\n{\n  int k = (n+1)\/2; \/\/ Nombre de ligne \u00e0 afficher\n  int m = 1;   \/\/ Nombre de A par ligne\n  for(int i=k-1; i&gt;=0; i--)\n  {\n    printLine(m, i);\n    m = m + 2;\n  }\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h4><a id=\"exercice-d-entrainement-a-ent2-3\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement A.ent2.3<\/h4>\n<p>Soit la fonction suivante.<\/p>\n<pre><code class=\"language-C\">int fact(int k)\n{\n  int p = 1;\n  for(int i=1; i &lt;= k; i++)\n  {\n    p = p * i;\n  }\n  return p;\n}\n<\/code><\/pre>\n<p>Donnez la valeur retourn\u00e9e par <code>fact(5)<\/code> et r\u00e9\u00e9crivez la fonction <code>fact<\/code> sans utiliser de <code>for<\/code> mais en utilisant un <code>while<\/code>. La nouvelle fonction doit se comporter en tous points comme l&rsquo;ancienne.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice 1<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>La valeur de retour est 120.<\/p>\n<p>Voici un squelette \u00e0 compl\u00e9ter de la nouvelle fonction.<\/p>\n<pre><code class=\"language-C\">int fact(int k)\n{\n  int p = 1;\n  \/\/ \u00c0 compl\u00e9ter\n  while(                 )\n  {\n    p = p * i;\n    \/\/ \u00c0 compl\u00e9ter\n  }\n  return p;\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 fact(int k)\n{\n  int p = 1;\n  int i = 1;\n  while(i &lt;= k)\n  {\n    p = p * i;\n    i++;\n  }\n  return p;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h3><a id=\"it%C3%A9ration-a-ent3\" class=\"anchor\" aria-hidden=\"true\"><\/a>It\u00e9ration A.ent3<\/h3>\n<h4><a id=\"exercice-d-entrainement-a-ent3-1\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement A.ent3.1<\/h4>\n<p>Le terme de rang &#40;i&#41; de la suite de Syracuse de valeur initiale &#40;k&#41;, not\u00e9 &#40;S_k(i)&#41;, est d\u00e9fini ainsi :<\/p>\n<ul>\n<li>\\(S_k(0) = k\\),<\/li>\n<li>Pour tout entier pair \\(i&gt;0\\), \\(S_k(i) = S_k(i-1) \/ 2\\),<\/li>\n<li>Pour tout entier impair \\(i&gt;0\\), \\(S_k(i) = 3 \\cdot S_k(i-1) + 1\\).<\/li>\n<\/ul>\n<p>Par exemple, les premiers termes de la suite de Syracuse de valeur initiale 6 sont les suivants :<\/p>\n<pre><code class=\"language-plain_text\">6, 3, 10, 5, 16, 8, 4, 2, 1, 4, 2, 1, 4, ...\n<\/code><\/pre>\n<p>Vous devez d\u00e9finir une fonction <code>int syr(int k, int i)<\/code> qui calcule le terme de rang <code>i<\/code> de la suite de Syracuse de valeur initiale <code>k<\/code>.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice 1<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-C\">int syr(int k, int i)\n{\n  int s = k;\n  for(int rang=1; rang &lt;= i; rang++)\n  {\n    \/\/ \u00c0 compl\u00e9ter\n  }\n  return s;\n}\n<\/code><\/pre>\n<p>Le terme de rang 0 est <code>k<\/code>. Il faut ensuite calculer les termes de rang 1 \u00e0 <code>i<\/code>. Chaque nouveau terme sera calcul\u00e9 par une it\u00e9ration de la boucle et remplacera le pr\u00e9c\u00e9dent dans la variable <code>s<\/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\">int syr(int k, int i)\n{\n  int s = k;\n  for(int rang=1; rang &lt;= i; rang++)\n  {\n    if(s % 2)\n    {\/\/ La valeur courante est impaire.\n        s = (3*s) + 1;\n    }\n    else\n    {\/\/ La valeur courante est paire.\n        s = s \/ 2;\n    }\n  }\n  return s;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h4><a id=\"exercice-d-entrainement-a-ent3-2\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement A.ent3.2<\/h4>\n<p>Voici le code d&rsquo;une fonction qui accepte deux param\u00e8tres de type <code>int<\/code> et retourne une valeur de type <code>int<\/code>.<\/p>\n<pre><code class=\"language-C\">int myst(int k, int i)\n{\n  int s = k;\n  for(int rang=1; rang &lt;= i; rang++)\n  {\n    if(s % 2)\n    {\/\/ La valeur courante est impaire.\n        s = (3*s) + 1;\n    }\n    else\n    {\/\/ La valeur courante est paire.\n        s = s \/ 2;\n    }\n  }\n  return s;\n}\n<\/code><\/pre>\n<p>Vous devez d\u00e9composer ce code en deux d\u00e9finitions de fonctions. Une fonction <code>myst<\/code> plus courte et sans <code>if<\/code> &#8230; <code>else<\/code>, et une autre fonction <code>calc<\/code> appel\u00e9e par la premi\u00e8re. Attention, pour que le programme compile, il faudra placer la d\u00e9finition de la fonction <code>calc<\/code> avant celle de la fonction <code>myst<\/code> dans le fichier source.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice 1<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-C\">\/\/ \u00c0 compl\u00e9ter avec la d\u00e9finition de calc\n\nint myst(int k, int i)\n{\n  int s = k;\n  for(int rang=1; rang &lt;= i; rang++)\n  {\n    s = calc(s);\n  }\n  return s;\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<p>Voici le code de la fonction <code>calc<\/code>.<\/p>\n<pre><code class=\"language-C\">int calc(int t)\n{\n  if(t % 2)\n    {\/\/ La valeur courante est impaire.\n        return (3*t) + 1;\n    }\n    else\n    {\/\/ La valeur courante est paire.\n        return t \/ 2;\n    }\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h4><a id=\"exercice-d-entrainement-a-ent3-2\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement A.ent3.2<\/h4>\n<p>Dans un jeu, on fait des tirages avec des d\u00e9s avec les modalit\u00e9s suivantes : on lance n d\u00e9s \u00e0 k faces et le r\u00e9sultat est le meilleur score des d\u00e9s lanc\u00e9s. Par exemple, avec n \u00e9gal \u00e0 3 et k \u00e9gal \u00e0 6, si les valeurs obtenues par les trois d\u00e9s sont 3, 5 et 5, le r\u00e9sultat du tirage est 5.<\/p>\n<p>Vous devez r\u00e9aliser une fonction <code>int tirage(int n, int k)<\/code> qui r\u00e9alise un tirage selon ces modalit\u00e9s et retourne le r\u00e9sultat. On suppose que n vaut au moins 1 et k au moins 2.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Indice 1<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-C\">int tirage(int n, int k)\n{\n  int resultat = 1 + (rand() % k);\n  for(                          )\n  {\n    \/\/ \u00c0 compl\u00e9ter\n  }\n  return resultat;\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\">Indice 2<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-C\">int tirage(int n, int k)\n{\n  int resultat = 1 + (rand() % k);\n  for(int i=0; i &lt; n-1; i++)\n  {\n    \/\/ Faire un lancer\n    \/\/ Si le score obtenu d\u00e9passe resultat\n    \/\/ alors mettre \u00e0 jour resultat.\n  }\n  return resultat;\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 tirage(int n, int k)\n{\n  int resultat = 1 + (rand() % k);\n  for(int i=0; i &lt; n-1; i++)\n  {\n    int lancer = 1 + (rand() % k);\n    if(lancer &gt; resultat)\n    {\n      resultat = lancer;\n    }\n  }\n  return resultat;\n}\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h2><a id=\"activit%C3%A9-a-top\" class=\"anchor\" aria-hidden=\"true\"><\/a>Activit\u00e9 A.top<\/h2>\n<p>Cette activit\u00e9 propose des exercices de <strong>consolidation<\/strong> qui ne doivent \u00eatre abord\u00e9s que par les personnes apprenantes ma\u00eetrisant bien la partie A et les parties suivantes disponibles, c&rsquo;est \u00e0 dire qui ont obtenu un score au moins \u00e9gal \u00e0 3 aux activit\u00e9s d\u00e9couverte et d&rsquo;entra\u00eenement de ces parties.<\/p>\n<p>Par exemple, si les parties actuellement disponibles sont A et B, vous devez d&rsquo;abord ma\u00eetriser la parie B avant de faire cette activit\u00e9 de consolidation de la partie A. Faire<\/p>\n<h3><a id=\"it%C3%A9ration-a-top1\" class=\"anchor\" aria-hidden=\"true\"><\/a>It\u00e9ration A.top1<\/h3>\n<p>Cette it\u00e9ration consiste \u00e0 traiter l&rsquo;exercice suivant.<\/p>\n<h4><a id=\"exercice-de-consolidation-a-top1\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de consolidation A.top1<\/h4>\n<p>On repr\u00e9sente une date l&rsquo;entier entier &#40;j + 100 \\cdot m + 10000 \\cdot a&#41;, o\u00f9 &#40;j&#41; est le Jour, &#40;m&#41; le mois et &#40;a&#41; l&rsquo;ann\u00e9e.<br \/>\nPar exemple, le 8 Janvier 2021 est cod\u00e9 par l&rsquo;entier dont la repr\u00e9sentation en base 10 est 20210108.<\/p>\n<p>Vous devez r\u00e9aliser les fonctions suivantes :<\/p>\n<ul>\n<li><code>int code(int j, int m, int a)<\/code> qui calcule le code d&rsquo;une date d&rsquo;apr\u00e8s son jour, moi et ann\u00e9e.<\/li>\n<li><code>int jour(int code)<\/code>, <code>int mois(int code)<\/code>, <code>int annee(int code)<\/code> qui retournent respectivement le jour, le mois et l&rsquo;ann\u00e9e d&rsquo;une date d&rsquo;apr\u00e8s son code.<\/li>\n<li><code>int compare(int date1, int date2)<\/code> qui compare chronologiquement les deux dates dont les codes sont pass\u00e9s en param\u00e8tres. si les deux dates sont identiques, la valeur de retour doit \u00eatre 0. Si la premi\u00e8re date est situ\u00e9e (chronologiquement) avant la deuxi\u00e8me, la valeur de retour doit \u00eatre n\u00e9gative. Si la deuxi\u00e8me date est ant\u00e9rieure \u00e0 la premi\u00e8re, la valeur de retour doit \u00eatre positive.<\/li>\n<\/ul>\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 codage consiste \u00e0 appliquer la formule donn\u00e9e par l&rsquo;\u00e9nonc\u00e9. La comparaison est \u00e9galement imm\u00e9diate, puisque par construction du code, une date \\(d_1\\) est situ\u00e9e avant \\(d_2\\) si et seulement si le code de \\(d_1\\) est plus petit que celui de \\(d_2\\).<\/p>\n<p>La principale difficult\u00e9 est de retrouver l&rsquo;ann\u00e9e, le mois et le jour \u00e0 partir du code d&rsquo;une date. On peut faire cela avec des divisions enti\u00e8res et des modulos.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<p>Avant de regarder les \u00e9l\u00e9ments de solution, testez-la sur votre sur machine.<\/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<p>Soit \\(c\\) le code d&rsquo;une date. Le jour est \\(c \\mod 100\\). Soit \\(c&rsquo; = c \\div 100\\). (Le symbole \\(\\div\\) repr\u00e9sente ici la division enti\u00e8re). Le mois est \\(c&rsquo; \\mod 100\\) et l&rsquo;ann\u00e9e \\(c&rsquo; \\div 100\\).<\/p>\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. Les bases du langage C Fonction principale, variables locales, affichage, instructions de contr\u00f4les, fonctions. 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 [&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-26","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\/26","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=26"}],"version-history":[{"count":4,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/posts\/26\/revisions"}],"predecessor-version":[{"id":482,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/posts\/26\/revisions\/482"}],"wp:attachment":[{"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/media?parent=26"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/categories?post=26"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/tags?post=26"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}