{"id":32,"date":"2021-12-20T16:10:21","date_gmt":"2021-12-20T16:10:21","guid":{"rendered":"https:\/\/9h15.net\/activ\/?p=32"},"modified":"2022-01-18T17:50:41","modified_gmt":"2022-01-18T17:50:41","slug":"c-et-c-partie-b","status":"publish","type":"post","link":"https:\/\/9h15.net\/activ\/c-et-c-partie-b\/","title":{"rendered":"C et C++ partie B"},"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=\"types-primitifs-repr%C3%A9sentation-binaires-bitwises-bool%C3%A9ens\" class=\"anchor\" aria-hidden=\"true\"><\/a>Types primitifs, repr\u00e9sentation binaires, bitwises, bool\u00e9ens<\/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<hr \/>\n<h2><a id=\"activit%C3%A9-de-d%C3%A9couverte-b-dec\" class=\"anchor\" aria-hidden=\"true\"><\/a>Activit\u00e9 de d\u00e9couverte B.dec<\/h2>\n<h3><a id=\"b-dec1-base-2-et-compl%C3%A9ment%C3%A0-2\" class=\"anchor\" aria-hidden=\"true\"><\/a>B.dec1 : Base 2 et compl\u00e9ment \u00e0 2<\/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>Base 2<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>La repr\u00e9sentation en base 2 d&rsquo;un entier naturel \\(x\\) est une d\u00e9composition de \\(x\\) en puissances de 2 :<\/p>\n<p>\\(x = 2^{n-1} \\cdot x_{n-1} + &#8230; + 2^0 \\cdot x_0 = \\sum_{i=0}^{n-1} 2^i \\cdot x_i\\).<\/p>\n<p><strong>Exemple :<\/strong> L&rsquo;entier dont la repr\u00e9sentation en base 10 est 19, c&rsquo;est \u00e0 dire \\(1 \\cdot 10^1 + 9 \\cdot 10^0\\), a pour repr\u00e9sentation en base 2 10011, c&rsquo;est \u00e0 dire \\(1 \\cdot 2^4 + 0 \\cdot 2^3 + 0 \\cdot 2^2 + 1 \\cdot 2^1 + 1 \\cdot 2^0\\).<\/p>\n<p>Avec \\(n\\) bits, on peut repr\u00e9senter en base 2 les entiers compris entre \\(0\\) et \\(2^n &#8211; 1\\). Par exemple, avec 4 bits on peut repr\u00e9senter les entiers dont les repr\u00e9sentations en base 2 sont comprises entre 0000 et 1111 et dont les repr\u00e9sentations en base 10 sont comprises entre 0 et 15.<\/p>\n<h4><a id=\"objectif\" class=\"anchor\" aria-hidden=\"true\"><\/a>Objectif<\/h4>\n<table>\n<thead>\n<tr>\n<th>Repr\u00e9senter des entiers relatifs en binaire.<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>On doit repr\u00e9senter des entiers positifs, n\u00e9gatifs ou nuls par des mots binaires.<\/p>\n<h4><a id=\"moyen\" class=\"anchor\" aria-hidden=\"true\"><\/a>Moyen<\/h4>\n<table>\n<thead>\n<tr>\n<th>Compl\u00e9ment \u00e0 2<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>La base 2 permet de repr\u00e9senter des entiers naturels, c&rsquo;est \u00e0 dire positifs ou nuls. Le codage en <strong>compl\u00e9ment \u00e0 deux<\/strong> permet de repr\u00e9senter aussi des entiers n\u00e9gatifs ou positifs avec des mots binaires. Plus pr\u00e9sis\u00e9ment, avec \\(n\\) bits on peut repr\u00e9senter les entiers compris dans l&rsquo;intervalle&#8230;<\/p>\n<p>\\[-2^{n-1} .. 2^{n-1}-1<br \/>\n\\]<\/p>\n<p>&#8230;En utilisant le principe suivant :<\/p>\n<ul>\n<li>Si \\(x \\geq 0\\) alors la repr\u00e9sentation en compl\u00e9ment \u00e0 2 de \\(x\\) est identique \u00e0 sa repr\u00e9sentation en base 2.<\/li>\n<li>Si \\(x &lt; 0\\) alors la repr\u00e9sentation en compl\u00e9ment \u00e0 2 de \\(x\\) est le repr\u00e9sentation en base 2 de \\(2^n+x\\).<\/li>\n<\/ul>\n<p><strong>Exemple :<\/strong> Avec 4 bits, on peut repr\u00e9senter en compl\u00e9ment \u00e0 2 les entiers compris entre -8 et 7.<\/p>\n<ul>\n<li>3 se repr\u00e9sente 0011, comme 3 en base 2.<\/li>\n<li>-3 se repr\u00e9sente 1101, comme 16-3 = 13 en base 2.<\/li>\n<li>-1 se repr\u00e9sente 1111, comme 16-1 = 15 en base 2.<\/li>\n<\/ul>\n<h4><a id=\"bonus\" class=\"anchor\" aria-hidden=\"true\"><\/a>Bonus<\/h4>\n<h5><a id=\"calcul-rapide-de-l-oppos%C3%A9\" class=\"anchor\" aria-hidden=\"true\"><\/a>Calcul rapide de l&rsquo;oppos\u00e9<\/h5>\n<p>Il existe un moyen rapide de calculer la repr\u00e9sentation en compl\u00e9ment \u00e0 2 de l&rsquo;oppos\u00e9 d&rsquo;un nombre : on conserve tous les bits en partant de la droite jusqu&rsquo;au premier 1 inclus et on compl\u00e9mente les autres.<\/p>\n<p><strong>Exemple :<\/strong><\/p>\n<p>La repr\u00e9sentation en compl\u00e9ment \u00e0 2 sur 4 bits de l&rsquo;entier 6 est 0110. (Elle est identique \u00e0 sa repr\u00e9sentation en base 2 puisqu&rsquo;il s&rsquo;agit d&rsquo;un entier positif.)<\/p>\n<p>Pour obtenir la repr\u00e9sentation de -6, on le d\u00e9compose en deux parties : 01 et 10. La coupure se situe \u00e0 gauche du bit \u00e0 1 en le plus \u00e0 droite. On compl\u00e9mente la partie de gauche. On obtient 1010. Si on recommence l&rsquo;op\u00e9ration, on obtient \u00e0 nouveau la repr\u00e9sentation de 6.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2021\/12\/1.png\" alt=\"image-20211203225328285\" \/><\/p>\n<h5><a id=\"d%C3%A9terminer-le-signe\" class=\"anchor\" aria-hidden=\"true\"><\/a>D\u00e9terminer le signe<\/h5>\n<p>Le signe d&rsquo;un nombre est indiqu\u00e9 par le bit le plus \u00e0 gauche de sa repr\u00e9sentation en compl\u00e9ment \u00e0 2. Si ce bit est 1 alors le nombre est n\u00e9gatif, sinon il est positif ou nul.<\/p>\n<h5><a id=\"exercice-de-d%C3%A9couverte-b-dec-x1\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte B.dec.x1<\/h5>\n<p>Donnez les repr\u00e9sentations en compl\u00e9ment \u00e0 2 sur 8 bits des entiers dont les repr\u00e9sentations d\u00e9cimales sont -1, 7 et -2.<\/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>Pour -1, on part de le repr\u00e9sentation en base 2 de 1 sur 8 bit, c&rsquo;est \u00e0 dire 0000 0001, puis on calcule l&rsquo;oppos\u00e9 en compl\u00e9mentant tous les bits \u00e0 gauche du bit \u00e0 1 le plus \u00e0 droite, ce qui donne 1111 1111.<\/p>\n<p>Pour 7, on conserve la repr\u00e9sentation en base 2, soit 0000 0111.<\/p>\n<p>Pour -2, en proc\u00e9dant de mani\u00e8re similaire \u00e0 -1, on obtient 1111 1110.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h5><a id=\"exercice-de-d%C3%A9couverte-b-dec-x2\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte B.dec.x2<\/h5>\n<p>Donnez les repr\u00e9sentations en compl\u00e9ment \u00e0 2 sur 8 bits des entiers dont les repr\u00e9sentations en compl\u00e9ment \u00e0 2 sur 4 bits sont 1011 et 0111.<\/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>Soit \\(x\\) le nombre dont la repr\u00e9sentation en compl\u00e9ment \u00e0 2 est 1011. Comme le bit le plus \u00e0 gauche est 1, on sait que \\(x\\) est n\u00e9gatif. La repr\u00e9sentation en base 2 de \\(-x\\) est 0101. Sur 8 bits, la repr\u00e9sentation en base 2 de \\(-x\\) est obtenue en ajoutant quatre 0 \u00e0 gauche, ce qui donne 0000 0101. Pour obtenir la repr\u00e9sentation de \\(x\\) en compl\u00e9ment \u00e0 2, il faut compl\u00e9menter tous les bits \u00e0 gauche du premier bit \u00e0 1 \u00e0 partir de la droite. <strong>Le r\u00e9sultat est 1111 1011.<\/strong><\/p>\n<p>Il existe un raccourci pour \u00e9tendre le nombre de bit d&rsquo;une repr\u00e9sentation en compl\u00e9ment \u00e0 2 d&rsquo;un nombre n\u00e9gatif. Il suffit d&rsquo;ajouter des 1 \u00e0 gauche. Ici on passe de 1011 \u00e0 1111 1011.<\/p>\n<p>Le nombre repr\u00e9sent\u00e9 en compl\u00e9ment \u00e0 2 par 0111 est positif, puisque le bit le plus \u00e0 gauche est 0. Sa repr\u00e9sentation en compl\u00e9ment \u00e0 2 est le m\u00eame que sa repr\u00e9sentation en base 2, et c&rsquo;est aussi valable sur 8 bit. La repr\u00e9sentation de ce nombre sur 8 bit est obtenue en ajoutant des 0 \u00e0 gauche. <strong>Le r\u00e9sultat est 0000 0111.<\/strong><\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h5><a id=\"exercice-de-d%C3%A9couverte-b-dec-x3\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte B.dec.x3<\/h5>\n<p>On consid\u00e8re le mot binaire 1110. Donnez l&rsquo;entier \\(x\\) repr\u00e9sent\u00e9 par ce mot en base 2 et l&rsquo;entier \\(y\\) repr\u00e9sent\u00e9 par ce mot en compl\u00e9ment \u00e0 2.<\/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 1110 est la repr\u00e9sentation en base 2 de \\(x\\), alors \\(x\\) vaut 14.<\/p>\n<p>Si 1110 est le repr\u00e9sentation en compl\u00e9ment \u00e0 2 de \\(y\\), alors \\(y\\) est n\u00e9gatif. Son oppos\u00e9 est repr\u00e9sent\u00e9 en base 2 par 0010. On a donc \\(-y = 2\\), d&rsquo;o\u00f9 \\(y=-2\\).<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h3><a id=\"b-dec2-repr%C3%A9sentation-hexad%C3%A9cimale\" class=\"anchor\" aria-hidden=\"true\"><\/a>B.dec2 : Repr\u00e9sentation hexad\u00e9cimale<\/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>Aucun<\/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 des mots binaires de mani\u00e8re condens\u00e9e et lisible<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Il faut pouvoir retrouver facilement (de t\u00eate avec un peu d&rsquo;entra\u00eenement) un mot binaire \u00e0 partir de sa repr\u00e9sentation condens\u00e9e et r\u00e9ciproquement. La repr\u00e9sentation en base 10 n&rsquo;est pas adapt\u00e9e car passer de la base 2 \u00e0 la base 10, et r\u00e9ciproquement, n\u00e9cessite des calculs.<\/p>\n<h4><a id=\"moyen\" class=\"anchor\" aria-hidden=\"true\"><\/a>Moyen<\/h4>\n<table>\n<thead>\n<tr>\n<th>Notation hexad\u00e9cimale<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>La repr\u00e9sentation hexad\u00e9cimale d&rsquo;un mot binaire consiste \u00e0 remplacer chaque groupe de 4 bits, appel\u00e9 nibble, par un chiffre ou une lettre avec la correspondance suivante.<\/p>\n<table>\n<thead>\n<tr>\n<th>nibble<\/th>\n<th>hexa<\/th>\n<th>nibble<\/th>\n<th>hexa<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>0000<\/td>\n<td>0<\/td>\n<td>1000<\/td>\n<td>8<\/td>\n<\/tr>\n<tr>\n<td>0001<\/td>\n<td>1<\/td>\n<td>1001<\/td>\n<td>9<\/td>\n<\/tr>\n<tr>\n<td>0010<\/td>\n<td>2<\/td>\n<td>1010<\/td>\n<td>A<\/td>\n<\/tr>\n<tr>\n<td>0011<\/td>\n<td>3<\/td>\n<td>1011<\/td>\n<td>B<\/td>\n<\/tr>\n<tr>\n<td>0100<\/td>\n<td>4<\/td>\n<td>1100<\/td>\n<td>C<\/td>\n<\/tr>\n<tr>\n<td>0101<\/td>\n<td>5<\/td>\n<td>1101<\/td>\n<td>D<\/td>\n<\/tr>\n<tr>\n<td>0110<\/td>\n<td>6<\/td>\n<td>1110<\/td>\n<td>E<\/td>\n<\/tr>\n<tr>\n<td>0111<\/td>\n<td>7<\/td>\n<td>1111<\/td>\n<td>F<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Par exemple, le mot binaire<code>0100 1100 0111 1111<\/code> est repr\u00e9sent\u00e9 par <code>4C7F<\/code>.<\/p>\n<p>Le passage de binaire \u00e0 hexad\u00e9cimal est imm\u00e9diat dans les deux sens. Le codage hexad\u00e9cimal est couramment utilis\u00e9 pour repr\u00e9senter des mots binaires de mani\u00e8re concise.<\/p>\n<p>La repr\u00e9sentation hexad\u00e9cimale peut \u00eatre aussi vue comme la repr\u00e9sentation d&rsquo;entiers naturels en base 16. Les lettres A \u00e0 F repr\u00e9sentent les valeurs 10 \u00e0 15.<\/p>\n<h5><a id=\"exercice-de-d%C3%A9couverte-b-dec-x4\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte B.dec.x4<\/h5>\n<p>Donnez la repr\u00e9sentation hexad\u00e9cimale du mot binaire 1101 1110 0111 0101.<\/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>DE75<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h5><a id=\"exercice-de-d%C3%A9couverte-b-dec-x5\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte B.dec.x5<\/h5>\n<p>Donnez le mot binaire dont la repr\u00e9sentation hexad\u00e9cimale est A31B.<\/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>1010 0011 0001 1011<\/p>\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>Hexad\u00e9cimal = Base 16<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>La notation hexad\u00e9cimale d&rsquo;un mot binaire \\(m\\) peut \u00eatre vue comme une <strong>repr\u00e9sentation en base 16<\/strong> de l&rsquo;entier dont \\(m\\) est la repr\u00e9sentation en base 2. Les symboles 0 \u00e0 9 et A \u00e0 F sont les chiffres de la base 16. Les symboles A \u00e0 F ont une valeur de respectivement 10, 11, 12, 13, 14, et 15 unit\u00e9s.<\/p>\n<p>Par exemple, <code>AF34<\/code> peut se d\u00e9composer en puissances de 16 sous la forme \\(10 \\cdot 16^3 + 15 \\cdot 16^2 + 3 \\cdot 16^1 + 4 \\cdot 16^0\\). On peut r\u00e9aliser des calculs directement en hexad\u00e9cimal, mais l&rsquo;int\u00e9r\u00eat reste limit\u00e9.<\/p>\n<h3><a id=\"b-dec3-types-entiers-affichage-hexa-sizeof\" class=\"anchor\" aria-hidden=\"true\"><\/a>B.dec3 : Types entiers, affichage hexa, sizeof<\/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>Repr\u00e9sentations en base 2, en compl\u00e9ment \u00e0 2 et hexad\u00e9cimale des entiers<\/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>Optimiser la quantit\u00e9 de m\u00e9moire utilis\u00e9e pour stocker des entiers.<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Certaines applications doivent traiter des millions, voire des milliards de valeurs num\u00e9riques. Il serait un peu b\u00eate d&rsquo;utiliser plus de m\u00e9moire que n\u00e9cessaire pour repr\u00e9senter ces entiers. Dans certains syst\u00e8mes embarqu\u00e9s ou objets connect\u00e9s, par exemple, un gaspillage de m\u00e9moire peut augmenter de mani\u00e8re cons\u00e9quente le co\u00fbt du mat\u00e9riel.<\/p>\n<p>Jusqu&rsquo;\u00e0 maintenant, nous avons utilis\u00e9 le type <code>int<\/code> pour repr\u00e9senter les entiers. Ce type repr\u00e9sente les entiers par des mots binaires dont la taille peut varier selon les architectures mat\u00e9rielles : 16 bits sur certains syst\u00e8me embarqu\u00e9s avec des ressources m\u00e9moire et CPU limit\u00e9es, 32 bits sur les ordinateurs que nous utilisons actuellement au quotidien (Mac, PC sous Windows ou Linux). Cette information, exprim\u00e9e en nombre d&rsquo;octets, peut \u00eatre obtenue en utilisant l&rsquo;instruction <code>sizeof<\/code>. Par exemple <code>sizeof(int)<\/code> vaut 4 sur les architecture 32 et 64 bits couramment utilis\u00e9es de nos jours : les donn\u00e9es de type <code>int<\/code> y sont repr\u00e9sent\u00e9es en m\u00e9moire par 4 octets, donc 32 bits.<\/p>\n<p>Le type <code>int<\/code> \u00e9tant sign\u00e9, il permet de repr\u00e9senter des entiers positifs et des entiers n\u00e9gatifs. Ces entiers sont repr\u00e9sent\u00e9s en compl\u00e9ment \u00e0 2. Dans la suite du cours, on fera toujours l&rsquo;hypoth\u00e8se de cette repr\u00e9sentation sur 32 bits, sauf mention particuli\u00e8re. Les valeurs repr\u00e9sentables par le type <code>int<\/code> sont donc comprises entre \\(-2^{31} .. 2^{31}-1\\), c&rsquo;est \u00e0 dire entre -2\u202f147\u202f483\u202f648 et 2\u202f147\u202f483\u202f647.<\/p>\n<p>Les valeurs minimum et maximum du type <code>int<\/code> sont donn\u00e9es par les constantes pr\u00e9d\u00e9finies <code>INT_MIN<\/code> et <code>INT_MAX<\/code> d\u00e9clar\u00e9es dans le fichier d&rsquo;ent\u00eate <code>limits.h<\/code>.<\/p>\n<p>Mais si on a besoin de repr\u00e9senter uniquement des valeurs positives, la moiti\u00e9 des mots binaires ne sont jamais utilis\u00e9s. Et si on a besoin de repr\u00e9senter uniquement des valeurs repr\u00e9sentables avec un seul octet, les trois quart de la m\u00e9moire utilis\u00e9e est monopolis\u00e9e inutilement.<\/p>\n<h4><a id=\"moyen\" class=\"anchor\" aria-hidden=\"true\"><\/a>Moyen<\/h4>\n<table>\n<thead>\n<tr>\n<th>Les types entiers sign\u00e9s et non sign\u00e9s de diff\u00e9rentes capacit\u00e9s<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<h5><a id=\"type-unsigned-int\" class=\"anchor\" aria-hidden=\"true\"><\/a>Type unsigned int<\/h5>\n<p>Il existe une version non sign\u00e9e du type <code>int<\/code>, le type <code>unsigned int<\/code>, not\u00e9 aussi <code>unsigned<\/code>. Les entiers repr\u00e9sent\u00e9s par ce type sont tous positifs. Leurs valeurs sont comprises entre 0 et \\(2^{32}-1\\).<\/p>\n<h5><a id=\"types-avec-diverses-tailles-de-repr%C3%A9sentation-en-m%C3%A9moire\" class=\"anchor\" aria-hidden=\"true\"><\/a>Types avec diverses tailles de repr\u00e9sentation en m\u00e9moire<\/h5>\n<p>Il existe \u00e9galement des version sign\u00e9es et non sign\u00e9es de types repr\u00e9sentant des entiers avec des repr\u00e9sentations en m\u00e9moire plus petites et plus grandes que celle du type <code>int<\/code>. Par ordre de taille croissante des repr\u00e9sentations en m\u00e9moire, nous avons <code>char<\/code>, <code>short<\/code>, <code>int<\/code>, <code>long<\/code> et <code>long long<\/code>, ainsi que les variantes non sign\u00e9es <code>unsigned char<\/code>, <code>unsigned short<\/code>, etc.<\/p>\n<p>Si j&rsquo;ex\u00e9cute le programme suivant sur ma machine&#8230;<\/p>\n<pre><code class=\"language-C\">int main()\n{\n    printf(\"taille d'un char en octets : %ld\\n\", sizeof(char));\n    printf(\"taille d'un short en octets : %ld\\n\", sizeof(short));\n    printf(\"taille d'un int en octets : %ld\\n\", sizeof(int));\n    printf(\"taille d'un long en octets : %ld\\n\", sizeof(long));\n    printf(\"taille d'un long long en octets : %ld\\n\", sizeof(long long));\n    return 0;\n}\n<\/code><\/pre>\n<p>&#8230;j&rsquo;obtiens le r\u00e9sultat :<\/p>\n<pre><code class=\"language-plain_text\">taille d'un char en octets : 1\ntaille d'un short en octets : 2\ntaille d'un int en octets : 4\ntaille d'un long en octets : 8\ntaille d'un long long en octets : 8\n<\/code><\/pre>\n<p>Observez d&rsquo;abord le programme. le format d&rsquo;affichage n&rsquo;est pas <code>%d<\/code> mais <code>%ld<\/code>. Pourquoi ? Ce genre de d\u00e9tails, des \u00e9l\u00e9ments nouveaux dans les programmes qui vous sont pr\u00e9sent\u00e9s, doit attirer votre attention.<\/p>\n<p>Le format %d affiche un entier en base 10 mais s&rsquo;applique au type <code>int<\/code> et aux types entiers ayant une plus petite taille. Les valeurs de ces derniers sont <strong>promues<\/strong> en <code>int<\/code>, c&rsquo;est \u00e0 dire que leur repr\u00e9sentation en m\u00e9moire est agrandie sans changement de leur valeur, avant affichage.<\/p>\n<p>Mais pour afficher correctement une valeur de type long, il faut utiliser le format <code>%ld<\/code> (l pour long et d pour d\u00e9cimal, i.e., on demande un affichage en base 10). Or la valeur de retour de <code>sizeof<\/code> est de type <code>long<\/code>.<\/p>\n<p>Maintenant, observons les r\u00e9sultats. On voit que chaque type a une repr\u00e9sentation m\u00e9moire de taille diff\u00e9rente sauf <code>long long<\/code> qui a la m\u00eame taille que <code>long<\/code>. Mais sur d&rsquo;autres architectures, on pourrait avoir une diff\u00e9rence de taille entre ces deux types, de m\u00eame que sur certaines architectures les <code>int<\/code> sont cod\u00e9s sur 2 octets comme les <code>short<\/code>.<\/p>\n<p>Cette souplesse sur les repr\u00e9sentations des entiers a permis au langage C de s&rsquo;adapter aux progr\u00e8s technologiques, mais peut poser probl\u00e8me en mati\u00e8re de portabilit\u00e9, c&rsquo;est \u00e0 dire si on recompile un programme sur une architecture diff\u00e9rente de celle d&rsquo;origine. C&rsquo;est pourquoi il existe aussi des types de tailles fixes, ind\u00e9pendantes de l&rsquo;architecture et du syst\u00e8me d&rsquo;exploitation utilis\u00e9s. Selon le nombre de bits de leurs repr\u00e9sentations en m\u00e9moire, ces types sont nomm\u00e9s <code>int8_t<\/code>, <code>int16_t<\/code>, <code>int32_t<\/code>, etc. pour les versions sign\u00e9es, et <code>uint8_t<\/code>, <code>uint16_t<\/code>, etc. pour les versions non sign\u00e9es.<\/p>\n<p>Il existe aussi un type nomm\u00e9 <code>size_t<\/code> d\u00e9di\u00e9s aux entiers ayant vocation \u00e0 repr\u00e9senter des tailles de donn\u00e9es en m\u00e9moire. C&rsquo;est le type de retour de <code>sizeof<\/code>. Dans les architectures 64 bits, ce type est \u00e9quivalent \u00e0 <code>unsigned long<\/code>.<\/p>\n<h5><a id=\"affichage-hexad%C3%A9cimal-des-entiers\" class=\"anchor\" aria-hidden=\"true\"><\/a>Affichage hexad\u00e9cimal des entiers<\/h5>\n<p>Tous les entiers peuvent \u00eatre repr\u00e9sent\u00e9s dans le code source au format hexad\u00e9cimal, et \u00e9galement affich\u00e9s par <code>printf<\/code> dans ce format. Voici un exemple.<\/p>\n<pre><code class=\"language-C\">int main()\n{\n  int a = 100;\n  int b = 0x100;\n  printf(\"a en d\u00e9cimal : %d, a en hexa : %x\\n\", a, a);\n  printf(\"b en d\u00e9cimal : %d, b en hexa : %x\\n\", b, b);  \n  return 0;\n}\n<\/code><\/pre>\n<p>On obtient l&rsquo;affichage :<\/p>\n<pre><code class=\"language-plain_text\">a en d\u00e9cimal : 100, a en hexa : 64\nb en d\u00e9cimal : 256, b en hexa : 100\n<\/code><\/pre>\n<p>On peut donc repr\u00e9senter un m\u00eame entier de plusieurs mani\u00e8res et l&rsquo;afficher dans plusieurs formats.<\/p>\n<h4><a id=\"bonus\" class=\"anchor\" aria-hidden=\"true\"><\/a>Bonus<\/h4>\n<table>\n<thead>\n<tr>\n<th>Double usage du type char<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Le type <code>char<\/code> peut <strong>aussi<\/strong> \u00eatre utilis\u00e9 pour repr\u00e9senter des caract\u00e8res imprimables, tels que <code>'a'<\/code>, <code>'D'<\/code>, <code>'2'<\/code>, etc., repr\u00e9senter par leurs codes <code>ASCII<\/code>. Le langage C ne fait pas de diff\u00e9rence entre les octets, les entiers cod\u00e9s sur 8 bits, et les caract\u00e8res <code>ASCII<\/code>, qui peuvent tous \u00eatre repr\u00e9sent\u00e9s par le type <code>char<\/code>. Voici un exemple.<\/p>\n<pre><code class=\"language-C\">int main()\n{\n  char x = 'z';\n  char y = 69;\n  printf(\"x en d\u00e9cimal : %d, x en hexa : %x, x en caract\u00e8re : %c\\n\", x, x, x);\n  printf(\"y en d\u00e9cimal : %d, y en hexa : %x, y en caract\u00e8re : %c\\n\", y, y, y);\n  return 0;\n}\n<\/code><\/pre>\n<p>L&rsquo;affichage obtenu est :<\/p>\n<pre><code class=\"language-plain_text\">x en d\u00e9cimal : 122, x en hexa : 7a, x en caract\u00e8re : z\ny en d\u00e9cimal : 69, y en hexa : 45, y en caract\u00e8re : E\n<\/code><\/pre>\n<h5><a id=\"exercice-de-d%C3%A9couverte-b-dec-x6\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte B.dec.x6<\/h5>\n<p>Donnez la ligne de code permettant d&rsquo;afficher le caract\u00e8re dont le code <code>ASCII<\/code> se note 41 en hexad\u00e9cimal.<\/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-plain_text\">printf(\"%c\\n\", 0x41);\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h5><a id=\"exercice-de-d%C3%A9couverte-b-dec-x7\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte B.dec.x7<\/h5>\n<p>Donnez la ligne de code permettant d&rsquo;afficher en hexad\u00e9cimal le code <code>ASCII<\/code> du caract\u00e8re &lsquo;9&rsquo;.<\/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-plain_text\">printf(\"%x\\n\", '9');\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h5><a id=\"exercice-de-d%C3%A9couverte-b-dec-x8\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte B.dec.x8<\/h5>\n<p>On ex\u00e9cute le programme suivant&#8230;<\/p>\n<pre><code class=\"language-C\">int main()\n{\n    char c = 129;\n    printf(\"%d\\n\", c);\n}\n<\/code><\/pre>\n<p>&#8230; et la valeur -127 est affich\u00e9e \u00e0 l&rsquo;\u00e9cran. Essayez d&rsquo;expliquer 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>Les type <code>char<\/code> repr\u00e9sente des entiers sign\u00e9s en compl\u00e9ment \u00e0 2 sur 8 bits. Les valeurs repr\u00e9sentables sont comprises entre -128 et 127. La valeur 129 n&rsquo;est pas repr\u00e9sentable. Le compilateur traduit 129 dans sa repr\u00e9sentation en base 2, \u00e0 savoir 1000 0001, et place cette valeur dans la zone m\u00e9moire o\u00f9 est stock\u00e9 le contenu de la variable <code>c<\/code>. Or 1000 0001 est la repr\u00e9sentation en compl\u00e9ment \u00e0 deux de l&rsquo;entier n\u00e9gatif -127.<\/p>\n<p>Si vous avez du mal \u00e0 comprendre exactement ce qui ce passe, ce n&rsquo;est pas grave pour l&rsquo;instant. Ce que vous devez comprendre, c&rsquo;est que :<\/p>\n<ol>\n<li>L&rsquo;utilisation d&rsquo;une valeur non repr\u00e9sentable avec le type utilis\u00e9 peut entra\u00eener des comportements apparemment incoh\u00e9rents, et que<\/li>\n<li>Le compilateur C ne d\u00e9tecte pas toujours ce genre de situation.<\/li>\n<\/ol>\n<p><\/div>\n\t\t\t<\/div>\n<h3><a id=\"b-dec4-op%C3%A9rations-bitwises\" class=\"anchor\" aria-hidden=\"true\"><\/a>B.dec4 : Op\u00e9rations bitwises<\/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>Types entiers et repr\u00e9sentation des entiers<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Il est essentiel de comprendre que toutes les donn\u00e9es manipul\u00e9es par un ordinateur, donc en pratique les contenus de toutes les variables, sont repr\u00e9sent\u00e9s en m\u00e9moire par des mots binaires (constitu\u00e9 d&rsquo;une suite d&rsquo;octets). En particulier toute donn\u00e9e, ou valeur, de type <code>int<\/code> peut \u00eatre utilis\u00e9e pour repr\u00e9senter un entier ou un mot binaire ou une valeur Bool\u00e9enne. Quand on utilise la valeur dans des op\u00e9rations arithm\u00e9tiques, on la consid\u00e8re comme un entier. Mais certaines op\u00e9rations que nous allons d\u00e9couvrir \u00ab\u00a0voient\u00a0\u00bb un entier comme un mot binaire. Plus pr\u00e9cis\u00e9ment, ces op\u00e9rations agissent sur le mot binaire repr\u00e9sentant cet entier.<\/p>\n<h4><a id=\"objectif\" class=\"anchor\" aria-hidden=\"true\"><\/a>Objectif<\/h4>\n<table>\n<thead>\n<tr>\n<th>Lire les bits de la repr\u00e9sentation binaire d&rsquo;un entier<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Le langage C permet de repr\u00e9senter dans un code source des constantes enti\u00e8res not\u00e9es en binaire. Par exemple on peut \u00e9crire&#8230;<\/p>\n<pre><code class=\"language-c\">unsigned int x = 0b111100001111;\n<\/code><\/pre>\n<p>&#8230;qui est strictement \u00e9quivalent \u00e0 :<\/p>\n<pre><code class=\"language-c\">unsigned int x = 0xF0F;\n<\/code><\/pre>\n<p>Par contre, aucun format d&rsquo;affichage de <code>printf<\/code> ne permet d&rsquo;affichage d&rsquo;un entier en binaire. Nous allons donc d\u00e9velopper une fonction permettant de le faire, ce qui permettra d&rsquo;introduire de nouveaux op\u00e9rateurs appel\u00e9 bitwises.<\/p>\n<p>Ces op\u00e9rateurs permettent d&rsquo;agir sur certains bits de mots binaires repr\u00e9sent\u00e9s par des valeurs de types entiers. Elle ne sont pas sp\u00e9cifiques au langage C. Par exemple, tous les op\u00e9rateurs pr\u00e9sent\u00e9s ici sont support\u00e9s par le langage Java et bien d&rsquo;autres.<\/p>\n<h4><a id=\"moyen\" class=\"anchor\" aria-hidden=\"true\"><\/a>Moyen<\/h4>\n<table>\n<thead>\n<tr>\n<th>Utiliser des op\u00e9rateurs bitwises<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Les op\u00e9rateurs bitwises sont le <strong>non<\/strong> bit \u00e0 bit, not\u00e9 <code>~<\/code>, le <strong>et<\/strong> bit \u00e0 bit, not\u00e9 <code>&amp;<\/code>, le <strong>ou<\/strong> bit \u00e0 bit, not\u00e9 <code>|<\/code>, le <strong>ou exclusif<\/strong> bit \u00e0 bit, not\u00e9 <code>^<\/code>, le <strong>d\u00e9calage \u00e0 droite<\/strong>, not\u00e9 <code>&gt;&gt;<\/code> et le <strong>d\u00e9calage \u00e0 gauche<\/strong>, not\u00e9 <code>&lt;&lt;<\/code>.<\/p>\n<p>Si on note, en commen\u00e7ant \u00e0 droite, $&#8230;, b_2, b_1, b_0$ les bits d&rsquo;un mot binaire repr\u00e9sentant en m\u00e9moire un entier $b$ (et pareillement pour d&rsquo;autres entiers a et c), alors les effets de ces op\u00e9rateurs sont les suivants.<\/p>\n<ul>\n<li><code>~a<\/code> est l&rsquo;entier obtenu en compl\u00e9mentant tous les bits de \\(a\\).<\/li>\n<li><code>a&amp;b<\/code> est l&rsquo;entier \\(c\\) tel que chaque \\(c_i\\) est le r\u00e9sultat d&rsquo;un et logique entre \\(a_i\\) et \\(b_i\\).<\/li>\n<li><code>a|b<\/code> est l&rsquo;entier \\(c\\) tel que chaque \\(c_i\\) est le r\u00e9sultat d&rsquo;un ou logique entre \\(a_i\\) et \\(b_i\\).<\/li>\n<li><code>a^b<\/code> est l&rsquo;entier \\(c\\) tel que chaque \\(c_i\\) est le r\u00e9sultat d&rsquo;un ou exclusif entre \\(a_i\\) et \\(b_i\\).<\/li>\n<li><code>a &gt;&gt; n<\/code> est l&rsquo;entier obtenu en d\u00e9calant de \\(n\\) positions \u00e0 droite tous les bits de la repr\u00e9sentation binaire de \\(a\\). Si le type de \\(a\\) est non sign\u00e9 ou si le type de \\(a\\) est sign\u00e9 et que la valeur de \\(a\\) est positive ou nulle, un bit 0 est introduit \u00e0 gauche. Si le type de \\(a\\) est sign\u00e9 et que la valeur de \\(a\\) est n\u00e9gative, alors un bit 1 est introduit \u00e0 gauche.<\/li>\n<li><code>a &lt;&lt; n<\/code> est l&rsquo;entier obtenu en d\u00e9calant de \\(n\\) positions \u00e0 gauche tous les bits de la repr\u00e9sentation binaire de \\(a\\) et en ins\u00e9rant un bit 0 \u00e0 droite.<\/li>\n<\/ul>\n<p>Voici quelques exemples sur des octets qui pourraient \u00eatre repr\u00e9sent\u00e9s par des entiers de type <code>unsigned char<\/code>.<\/p>\n<pre><code class=\"language-plain_text\">    a : 0000 1111          a : 0000 1111          \n    b : 0011 1100          b : 0011 1100          a : 0000 1111\n-----------------      -----------------      -----------------\na &amp; b : 0000 1100      a | b : 0011 1111         ~a : 1111 0000\n<\/code><\/pre>\n<pre><code class=\"language-plain_text\">     a : 0011 1100           a : 0011 1100\n------------------      ------------------ \na &gt;&gt; 3 : 0000 0111      a &lt;&lt; 3 : 1110 0000 \n<\/code><\/pre>\n<hr \/>\n<p>Nous allons, \u00e0 titre d&rsquo;exemple d&rsquo;utilisation des ces op\u00e9rateurs, d\u00e9finir une fonction qui affiche la repr\u00e9sentation en base 2 d&rsquo;un entier. Plus pr\u00e9cis\u00e9ment, cette fonction a deux param\u00e8tres nomm\u00e9s <code>valeur<\/code> et <code>nBits<\/code>. Elle affiche les <code>nbBits<\/code> derniers bits de <code>valeur<\/code>.<\/p>\n<p>Par exemple, <code>printB2(17, 8)<\/code> affichera <code>0001 0001<\/code>, et <code>printB2(0x17, 8 )<\/code> affichera <code>0001 0111<\/code>.<\/p>\n<p>Illustrons le principe utilis\u00e9 dans le cas ou le param\u00e8tre <code>nBits<\/code> vaut 8. On cr\u00e9e un masque, qui est le mot binaire 1000 0000, c&rsquo;est \u00e0 dire avec un bit 1 dans le position du bit \u00e0 afficher le plus \u00e0 gauche, suivi de bits 0. Ensuite, tant que ce masque n&rsquo;est pas \u00e9gal \u00e0 0000 0000, on affiche le bit de <code>valeur<\/code> situ\u00e9 en face du bit \u00e0 1 du masque et on d\u00e9cale le masque d&rsquo;une position vers la droite.<\/p>\n<p>Voici une version incompl\u00e8te qui montre l&rsquo;initialisation du masque et la boucle qui fait \u00e9voluer sa valeur, mais sans entrer dans le d\u00e9tail d&rsquo;affichage de cette valeur.<\/p>\n<pre><code class=\"language-C\">void printB2(int valeur, int nBits)\n{\n  unsigned masque = 1 &lt;&lt; (nBits-1);\n  while(masque &gt; 0)\n  {\n    \/\/ Affichage du bit de valeur s\u00e9lectionn\u00e9\n    \/\/ par le masque.\n    masque = masque &gt;&gt; 1;\n  }\n}\n<\/code><\/pre>\n<p>Essayez de bien comprendre le fonctionnement de cette partie du code avant de poursuivre. Vous pouvez par exemple l&rsquo;ex\u00e9cuter \u00e0 la main avec la valeur 5 et un affichage sur 4 bits, c&rsquo;est \u00e0 dire simuler l&rsquo;ex\u00e9cution de <code>printB2(5, 4)<\/code>. Vous pouvez v\u00e9rifier votre pr\u00e9diction en pla\u00e7ant dans le corps de la boucle la ligne d&rsquo;affichage <code>printf(\"%x \", masque)<\/code> et en testant sur machine l&rsquo;ex\u00e9cution de la fonction. Vous pouvez aussi consulter la r\u00e9ponse cach\u00e9e suivante.<\/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>Les valeurs successives du masque, en hexad\u00e9cimal, sont 8, 4, 2, 1, puis la valeur 0, qui ne sera pas affich\u00e9e. En binaire, ces valeurs sont 1000, 0100, 0010, 0001.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<p>Il nous reste \u00e0 compl\u00e9ter le code de mani\u00e8re \u00e0 ce qu&rsquo;il affiche, pour chaque valeur du masque, le bit \u00e9chantillonn\u00e9. Essayez de trouver une solution en utilisant l&rsquo;op\u00e9rateur <code>&amp;<\/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>Pour d\u00e9terminer la valeur du bit d\u00e9sign\u00e9 par le masque, on peut r\u00e9aliser l&rsquo;op\u00e9ration <code>masque &amp; valeur<\/code>. Si le bit lu vaut 0, le r\u00e9sultat est 0, sinon le r\u00e9sultat est diff\u00e9rent de 0.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<p>Voici le code complet de la fonction.<\/p>\n<pre><code class=\"language-C\">void printB2(int valeur, int nBits)\n{\n  unsigned masque = 1 &lt;&lt; (nBits-1);\n  while(masque &gt; 0)\n  {\n    if(masque &amp; valeur)\n    {\n      printf(\"1\");\n    }\n    else\n    {\n      printf(\"0\");\n    }\n    masque = masque &gt;&gt; 1;\n  }\n}\n<\/code><\/pre>\n<h4><a id=\"nouvel-objectif\" class=\"anchor\" aria-hidden=\"true\"><\/a>Nouvel objectif<\/h4>\n<table>\n<thead>\n<tr>\n<th>Modifier certains bits dans un mot binaire sans changer les autres<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>L&rsquo;objectif pr\u00e9c\u00e9dent n\u00e9cessitait de lire des bits dans un mot binaire repr\u00e9sent\u00e9 par une valeur de type entier. Mais il arrive qu&rsquo;on souhaite modifier certains bits, par exemple quand on configure des ports d&rsquo;entr\u00e9es sortie de microcontr\u00f4leur, ou encore quand on g\u00e8re des droit d&rsquo;acc\u00e8s \u00e0 des fichiers en programmation syst\u00e8me sous <code>UNIX<\/code>.<\/p>\n<h4><a id=\"moyen\" class=\"anchor\" aria-hidden=\"true\"><\/a>Moyen<\/h4>\n<table>\n<thead>\n<tr>\n<th>Utilisation d&rsquo;un masque et d&rsquo;une op\u00e9ration bitwise<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Nous avons vu comment cr\u00e9er un masque et l&rsquo;utiliser pour lire la valeur d&rsquo;un bit particulier de la repr\u00e9sentation binaire d&rsquo;un entier (c&rsquo;est \u00e0 dire de sa repr\u00e9sentation en m\u00e9moire). Nous allons maintenant d\u00e9couvrir comment <strong>modifier<\/strong> la valeur d&rsquo;un bit.<\/p>\n<p>Voici un premier exemple. Soit <code>x<\/code> une variable de type <code>int<\/code>. On souhaite mettre \u00e0 1 le bit de rang 5 dans la repr\u00e9sentation binaire de l&rsquo;entier situ\u00e9 <code>x<\/code>. Les rangs des bits sont num\u00e9rot\u00e9s \u00e0 partir de 0 en partant de la droite. On peut obtenir ce r\u00e9sultat avec un masque et l&rsquo;op\u00e9rateur <code>|<\/code>.<\/p>\n<pre><code class=\"language-C\">int x = 0b00001111;\nx = x | 0b00100000;\nprintB2(x,8); printf(\"\\n\");\n<\/code><\/pre>\n<p>On obtient l&rsquo;affichage <code>00101111<\/code>.<\/p>\n<p>Incidemment, on d\u00e9couvre ici un moyen d&rsquo;\u00e9crire un entier repr\u00e9sent\u00e9 en base 2 dans du code source en langage C. 0b000111 repr\u00e9sente la m\u00eame entier que 0b111 ou 7 ou 0x7, par exemple. (Par contre il n&rsquo;existe pas de format d&rsquo;affichage <code>%b<\/code> pour <code>printf<\/code>, c&rsquo;est pourquoi nous avons d\u00e9fini une fonction <code>printB2<\/code>.)<\/p>\n<p>Voici maintenant un autre exemple dans lequel on va mettre \u00e0 0 un bit de la repr\u00e9sentation binaire d&rsquo;un entier.<\/p>\n<pre><code class=\"language-C\">int x = 0b00001111;\nx = x &amp; (~ 0b00000010);\nprintB2(x,8); printf(\"\\n\");\n<\/code><\/pre>\n<p>On obtient l&rsquo;affichage <code>00001101<\/code>.<\/p>\n<p>Le principe utilis\u00e9 consiste \u00e0 cr\u00e9er un masque dont tous les bits sont \u00e0 1 sauf celui dans la position o\u00f9 on souhaite placer la valeur 0 dans la donn\u00e9e \u00e0 modifier. On r\u00e9alise alors un et bit \u00e0 bit entre ce masque et la donn\u00e9e \u00e0 modifier.<\/p>\n<h4><a id=\"exercices-de-d%C3%A9couverte\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercices de d\u00e9couverte<\/h4>\n<h5><a id=\"exercice-de-d%C3%A9couverte-b-dec-x9\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte B.dec.x9<\/h5>\n<p>Le format %02x affiche un entier en repr\u00e9sentation hexad\u00e9cimal avec deux chiffres (et \/ ou lettres) en compl\u00e9tant au besoin avec des 0 \u00e0 gauche. Par exemple, 9 sera affich\u00e9 09 et 2B sera affich\u00e9 2B. (On peut remplacer %02 par %03, %04, etc.)<\/p>\n<p>Donnez les affichages r\u00e9alis\u00e9s par l&rsquo;ex\u00e9cution des lignes de code suivantes.<\/p>\n<pre><code class=\"language-C\">printf(\"%02x\\n\", 0b111100 &amp; 0b101);\nprintf(\"%02x\\n\", 0b111100 | 0b101);\nprintf(\"%02x\\n\", 0b111100 &lt;&lt; 2);\nprintf(\"%02x\\n\", 0b111100 &gt;&gt; 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\">04\n3d\nf0\n07\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h5><a id=\"exercice-de-d%C3%A9couverte-b-dec-x10\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte B.dec.x10<\/h5>\n<p>Soit une variable <code>x<\/code> de type unsigned <code>int<\/code>. Donnez une ligne de code permettant de mettre \u00e0 1 le bit de rang 7 de la repr\u00e9sentation binaire du contenu de <code>x<\/code>. (Le bit de rang 7 est le 8i\u00e8me en partant de la droite puisque par convention les bits sont num\u00e9rot\u00e9s \u00e0 partir de 0.)<\/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\">x = x | 0b10000000;\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h5><a id=\"exercice-de-d%C3%A9couverte-b-dec-x11\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte B.dec.x11<\/h5>\n<p>Donnez les affichages r\u00e9alis\u00e9s par l&rsquo;ex\u00e9cution des lignes de code suivantes.<\/p>\n<pre><code class=\"language-C\">int x = 0b1111111111111111;\nx = x &amp; 0b1111011111111111;\nprintB2(x, 16); printf(\"\\n\");\nprintB2(x, 24); printf(\"\\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<pre><code class=\"language-plain_text\">1111011111111111\n000000001111011111111111\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h3><a id=\"b-dec5-bitwises-versus-bool%C3%A9ens\" class=\"anchor\" aria-hidden=\"true\"><\/a>B.dec5 : Bitwises versus Bool\u00e9ens<\/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 la repr\u00e9sentation des mots binaire par des entiers et des valeurs Bool\u00e9ennes vrai et faux par des entiers.<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Les entiers du langage C sont des donn\u00e9es \u00e0 usage multiple. Selon le contexte, une valeur de type <code>int<\/code> peut repr\u00e9senter un nombre entier, un mot binaire, un caract\u00e8re imprimable, mais aussi une valeur Bool\u00e9enne. Dans ce dernier cas, par convention, la valeur 0 repr\u00e9sente faux alors que toute valeur autre que 0 repr\u00e9sente vrai.<\/p>\n<h4><a id=\"objectif\" class=\"anchor\" aria-hidden=\"true\"><\/a>Objectif<\/h4>\n<table>\n<thead>\n<tr>\n<th>Exprimer des conditions complexes combinant plusieurs valeurs Bool\u00e9ennes.<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Les op\u00e9rateurs bitwises ne sont pas adapt\u00e9s \u00e0 la r\u00e9alisation d&rsquo;op\u00e9rations logiques sur des Bool\u00e9ens. L&rsquo;exemple suivant permet de le constater.<\/p>\n<pre><code class=\"language-c\">int x = 1; int y = 2;\nif(x &amp; y) printf(\"YES\\n\"); else printf(\"NO\\n\");\n<\/code><\/pre>\n<p>Par convention, les entiers 1 et 2 repr\u00e9sentent la valeur <strong>vrai<\/strong>. Un <strong>et logique<\/strong> entre les deux devrait donc avoir pour r\u00e9sultat la valeur <strong>vrai<\/strong>. Or quand on ex\u00e9cute les deux lignes de codes ci dessus, on obtient l&rsquo;affichage <code>NO<\/code>, indiquant que <code>1 &amp; 2<\/code> repr\u00e9sente <strong>faux<\/strong>.<\/p>\n<p>Essayez de trouver l&rsquo;explication avant de la r\u00e9v\u00e9ler.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Explication<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>D&rsquo;un point de vue Bool\u00e9en, 1 et 2 repr\u00e9sentent tous les deux la valeur vrai et <code>1 &amp;&amp; 2<\/code> a pour r\u00e9sultat vrai (repr\u00e9sent\u00e9 par l&rsquo;entier 1). Mais d&rsquo;un point de vue bitwise, 1 est repr\u00e9sent\u00e9 par le mot binaire <code>...0001<\/code> et 2 est repr\u00e9sente par <code>...0010<\/code>. Un et bitwise entre les deux a pour r\u00e9sultat 0, qui est interpr\u00e9t\u00e9 comme la valeur faux.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h4><a id=\"moyen\" class=\"anchor\" aria-hidden=\"true\"><\/a>Moyen<\/h4>\n<table>\n<thead>\n<tr>\n<th>Pour r\u00e9aliser des op\u00e9rations logiques, aussi appel\u00e9es Bool\u00e9ennes, il faut utiliser des op\u00e9rateurs Bool\u00e9ens et non des op\u00e9rateurs bitwises.<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Il est important de ne pas confondre les op\u00e9rateurs bitwises et les op\u00e9rateurs Bool\u00e9ens.<\/p>\n<p>Les op\u00e9rateurs bitwises agissent sur les bits des mots binaires repr\u00e9sentant des entiers alors que les op\u00e9rateurs Bool\u00e9ens consid\u00e8rent chaque entier comme repr\u00e9sentant une unique valeur Bool\u00e9enne : la valeur 0 repr\u00e9sente faux et toute autre valeur repr\u00e9sente vrai.<\/p>\n<p>Les op\u00e9rateurs logiques suivants existent en version bitwise et en version Bool\u00e9enne.<\/p>\n<table>\n<thead>\n<tr>\n<th><\/th>\n<th>bitwise<\/th>\n<th>Bool\u00e9en<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>et<\/td>\n<td>&amp;<\/td>\n<td>&amp;&amp;<\/td>\n<\/tr>\n<tr>\n<td>ou<\/td>\n<td>|<\/td>\n<td>||<\/td>\n<\/tr>\n<tr>\n<td>non<\/td>\n<td>~<\/td>\n<td>!<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Le r\u00e9sultat d&rsquo;une op\u00e9ration Bool\u00e9enne est 0 (pour faux) ou 1 (pour vrai), m\u00eame si les op\u00e9randes peuvent avoir des valeurs diff\u00e9rentes de 0 et 1 (pour m\u00e9moire, toute valeur diff\u00e9rente de 0 sera interpr\u00e9t\u00e9e comme vrai).<\/p>\n<p>Ajoutons une ligne \u00e0 l&rsquo;exemple pr\u00e9c\u00e9dent.<\/p>\n<pre><code class=\"language-C\">int x = 1; int y = 2;\nif(x &amp; y) printf(\"YES\\n\"); else printf(\"NO\\n\");\nif(x &amp;&amp; y) printf(\"YES\\n\"); else printf(\"NO\\n\");\n<\/code><\/pre>\n<p>L&rsquo;affichage \u00e0 l&rsquo;ex\u00e9cution est :<\/p>\n<pre><code class=\"language-plain_text\">NO\nYES\n<\/code><\/pre>\n<h4><a id=\"bonus\" class=\"anchor\" aria-hidden=\"true\"><\/a>Bonus<\/h4>\n<table>\n<thead>\n<tr>\n<th>Op\u00e9rateurs de comparaison et pi\u00e8ge du =<\/th>\n<\/tr>\n<\/thead>\n<\/table>\n<p>Les op\u00e9rateurs de comparaisons <code>==<\/code>, <code>!=<\/code>, <code>&lt;<\/code>, <code>&gt;<\/code>, <code>&gt;=<\/code>, <code>&lt;=<\/code> permettent de comparer des valeurs num\u00e9riques, (entiers et flottants) et produise un r\u00e9sultat de type <code>int<\/code> repr\u00e9sentant une valeur Bool\u00e9enne. Par exemple, en ex\u00e9cutant la ligne suivante&#8230;<\/p>\n<pre><code class=\"language-c\">printf(\"%d\\n\", 2 != 27);\n<\/code><\/pre>\n<p>&#8230;on observe l&rsquo;affichage <code>1<\/code> qui s&rsquo;interpr\u00e8te comme la valeur Bool\u00e9enne <strong>vrai<\/strong>.<\/p>\n<p>Il faut prendre garde \u00e0 ne pas utiliser <code>=<\/code> \u00e0 la place de <code>==<\/code>. Observons le code suivant :<\/p>\n<pre><code class=\"language-c\">int x = 0;\nif(x = 17) printf(\"YES\\n\"); else printf(\"NO\\n\");\n<\/code><\/pre>\n<p>Si vous utilisez l&rsquo;option de compilation -Wall ou utilisez un IDE bien configur\u00e9, vous devriez avoir un message d&rsquo;avertissement \u00e0 la compilation, mais cela n&#8217;emp\u00eache pas la production d&rsquo;un code ex\u00e9cutable.<\/p>\n<p>\u00c0 l&rsquo;ex\u00e9cution, on observe l&rsquo;affichage <code>YES<\/code>, et ceci en raison du cumul de deux effets. Premi\u00e8rement, l&rsquo;instruction <code>x = 17<\/code> ne fais pas une comparaison mais une affectation, donc <code>x<\/code> prend la valeur 17. Deuxi\u00e8mement, en langage C, une affectation retourne la valeur assign\u00e9e, donc <code>x = 17<\/code> retourne la valeur 17, qui est interpr\u00e9t\u00e9e comme le Bool\u00e9en <strong>vrai<\/strong>.<\/p>\n<p><strong>Le langage C comporte de nombreux pi\u00e8ges comme celui-ci. Vous en \u00e9viterez beaucoup en prenant garde \u00e0 tous les avertissements produit lors de la compilation de vos codes sources.<\/strong><\/p>\n<h5><a id=\"exercice-de-d%C3%A9couverte-b-dec-x12\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de d\u00e9couverte B.dec.x12<\/h5>\n<p>Une confusion entre le non bitwise <code>~<\/code> et le non Bool\u00e9en <code>!<\/code> peut-elle poser probl\u00e8me ? Si oui, donnez un exemple.<\/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>En effet, cela pose probl\u00e8me. Par exemple l&rsquo;entier 1 repr\u00e9sente le Bool\u00e9en vrai. L&rsquo;op\u00e9ration <code>!1<\/code> a pour r\u00e9sultat 0, qui s&rsquo;interpr\u00e8te comme le Bool\u00e9en faux, tandis que <code>~ 1<\/code> a pour r\u00e9sultat l&rsquo;entier repr\u00e9sent\u00e9 par le mot binaire dont tous les bits sauf le dernier sont \u00e0 1, qui s&rsquo;interpr\u00e8te comme le Bool\u00e9en vrai.<\/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<hr \/>\n<h2><a id=\"activit%C3%A9-d-entrainement-b-ent\" class=\"anchor\" aria-hidden=\"true\"><\/a>Activit\u00e9 d&rsquo;entrainement B.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;entrainement 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-b-ent1\" class=\"anchor\" aria-hidden=\"true\"><\/a>It\u00e9ration B.ent1<\/h3>\n<h4><a id=\"exercice-b-ent1-1\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice B.ent1.1<\/h4>\n<p>Sans utiliser d&rsquo;ordinateur, donnez les affichages re\u0301alise\u0301s par chacune de ces lignes de code :<\/p>\n<pre><code class=\"language-C\">printf(\"%d \", 15 &amp; 9); \nprintf(\"%x \", 0xA &amp; 0x5);\nprintf(\"%d \", 0x80 | (3 &lt;&lt; 2));\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\">9 0 140 \n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h4><a id=\"exercice-b-ent1-2\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice B.ent1.2<\/h4>\n<p>Vous devez r\u00e9aliser une fonction <code>uint16_t writeBit(uint16_t data, int pos, int val)<\/code> qui produit l&rsquo;entier obtenu en modifiant dans <code>data<\/code> le bit situ\u00e9 en position <code>pos<\/code> en lui donnant la valeur <code>val<\/code>. On suppose que <code>pos<\/code> est un entier compris entre 0 et 15 et que <code>val<\/code> vaut 0 ou 1. Le type <code>uint16_t<\/code> d\u00e9signe des entier non sign\u00e9s repr\u00e9sent\u00e9s sur 16 bits. Si vous testez votre solution sur machine, ce qui est recommand\u00e9, il faudra inclure le fichier d&rsquo;ent\u00eate <code>stdint.h<\/code> pour pouvoir utiliser ce type.<\/p>\n<p>Voici un exemple de fonction <code>main<\/code> permettant de tester votre solution.<\/p>\n<pre><code class=\"language-C\">int main()\n{\n    uint16_t a = 0xFF00;\n    printB2(writeBit(a, 3, 1), 16); printf(\"\\n\");\n    printB2(writeBit(a, 9, 0), 16); printf(\"\\n\");\n}\n<\/code><\/pre>\n<p>Pour v\u00e9rifier que vous avez bien compris ce que doit faire la fonction <code>writeBit<\/code>, tentez de d\u00e9terminer ce qui doit \u00eatre affich\u00e9 par l&rsquo;ex\u00e9cution de ce programme. V\u00e9rifiez ensuite en regardant la r\u00e9ponse.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">Affichage du programme de test<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-plain_text\">1111111100001000\n1111110100000000\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<p>Si vous avez bien compris ce que doit faire la fonction <code>writeBit<\/code>, vous pouvez traiter l&rsquo;exercice.<\/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\">uint16_t writeBit(uint16_t data, int pos, int val)\n{\n    uint16_t masque = 1 &lt;&lt; pos;\n    if(val)\n    {\/\/ mettre un bit \u00e0 1\n        \/\/ \u00c0 compl\u00e9ter\n    }\n    else\n    {\/\/ mettre un bit \u00e0 0\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\">Solution<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-C\">uint16_t writeBit(uint16_t data, int pos, int val)\n{\n    uint16_t masque = 1 &lt;&lt; pos;\n    if(val)\n    {\/\/ mettre un bit \u00e0 1\n        return data | masque;\n    }\n    else\n    {\/\/ mettre un bit \u00e0 0\n        return data &amp; (~masque);\n    }\n}\n<\/code><\/pre>\n<p>Si votre solution ne correspond pas exactement \u00e0 celle-ci, v\u00e9rifiez sur machine ou aupr\u00e8s d&rsquo;une personne enseignante si elle est correcte.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h4><a id=\"exercice-b-ent1-3\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice B.ent1.3<\/h4>\n<p>Soit <code>x<\/code> une variable de type <code>unsigned int<\/code>. Donnez les lignes de code permettant de r\u00e9aliser les calculs suivants en utilisant exclusivement des op\u00e9rations bitwises, i.e., <code>&amp; ~ | ^ &lt;&lt; &gt;&gt;<\/code>. Le r\u00e9sultat doit \u00eatre plac\u00e9 dans la variable <code>x<\/code>.<\/p>\n<p><strong>Q1.<\/strong> Diviser <code>x<\/code> par 8.<\/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\">x = x &gt;&gt; 3;\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<p><strong>Q2<\/strong>. Multiplier <code>x<\/code> par 4.<\/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\">x = x &lt;&lt; 2;\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<p><strong>Q3.<\/strong> Calculer 4 <code>x<\/code> + 3.<\/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\">x = (x &lt;&lt; 2) | 3\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<p><strong>Q4.<\/strong> Calculer <code>x<\/code> modulo 16.<\/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\">x = x &amp; 0b1111;\n<\/code><\/pre>\n<p>Pour bien comprendre cette solution, il faut comprendre que pour diviser par 16 il faut 4 d\u00e9calages \u00e0 droite. Les bits perdu lors d&rsquo;un tels d\u00e9calage repr\u00e9sentent le reste de la division enti\u00e8re. On les r\u00e9cup\u00e8re ici en mettant tous les autres \u00e0 0.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h3><a id=\"it%C3%A9ration-b-ent2\" class=\"anchor\" aria-hidden=\"true\"><\/a>It\u00e9ration B.ent2<\/h3>\n<h4><a id=\"exercice-d-entrainement-b-ent2-1\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement B.ent2.1<\/h4>\n<p>Sans utiliser d&rsquo;ordinateur, donnez les affichages re\u0301alise\u0301s par chacune de ces lignes de code :<\/p>\n<pre><code class=\"language-C\">printf(\"%d \", 16 | 1); \nprintf(\"%x \", 0xF0 &amp; 0x1A);\nprintf(\"%d \", 0x0F | (0x800 &gt;&gt; 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\">17 10 143 \n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h4><a id=\"exercice-d-entrainement-b-ent2-2\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement B.ent2.2<\/h4>\n<p>Vous devez r\u00e9aliser une fonction <code>uint16_t rotateRight(uint16_t data)<\/code> qui retourne l&rsquo;entier dont la repr\u00e9sentation binaire r\u00e9sulte d&rsquo;une rotation \u00e0 droite d&rsquo;un mot binaire de 16 bits. Par \u00ab\u00a0rotation \u00e0 droite\u00a0\u00bb, on entend que tous les bits sauf le plus \u00e0 droite sont d\u00e9cal\u00e9s vers la droite et que le bit le plus \u00e0 droite se retrouve compl\u00e8tement \u00e0 gauche.<\/p>\n<p>Par exemple, le programme de test suivant&#8230;<\/p>\n<pre><code class=\"language-C\">int main()\n{\n    uint16_t a = 0xFF00;\n    uint16_t b = 0x00FF;\n    printf(\"%04x \\n\", rotateRight(a));\n    printf(\"%04x \\n\", rotateRight(b));\n}\n<\/code><\/pre>\n<p>&#8230;devrait afficher :<\/p>\n<pre><code class=\"language-plain_text\">7f80 \n807f \n<\/code><\/pre>\n<p>Si cela ne vous parait pas \u00e9vident, repr\u00e9sentez les donn\u00e9es en base 2 et simulez \u00e0 la main leurs rotations \u00e0 droite et gauche.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">R\u00e9sultat<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-plain_text\">1111 1111 0000 0000 -&gt; 0111 1111 1000 0000\n0000 0000 1111 1111 -&gt; 1000 0000 0111 1111\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<p>Si vous avez bien compris en quoi consiste la rotation \u00e0 droite, vous pouvez traiter l&rsquo;exercice.<\/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\">uint16_t rotateRight(uint16_t data)\n{\n    int b0 = data &amp; 1;\n    \/\/ \u00c0 compl\u00e9ter\n}\n<\/code><\/pre>\n<p>La variable <code>b0<\/code> contient la valeur du bit le plus \u00e0 droite. Vous pouvez obtenir le r\u00e9sultat recherch\u00e9 en combinant deux mots binaires :<\/p>\n<ul>\n<li>le mot obtenu en d\u00e9calant <code>b0<\/code> de 15 position \u00e0 gauche,<\/li>\n<li>le mot obtenu en d\u00e9calant data d&rsquo;une position \u00e0 droite.<\/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\">R\u00e9ponse<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-C\">uint16_t rotateRight(uint16_t data)\n{\n    int b0 = data &amp; 1;\n    return (b0 &lt;&lt; 15) | (data &gt;&gt; 1); \n}\n<\/code><\/pre>\n<p>Des variantes sont possibles. En cas de doute, testez la votre.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h4><a id=\"exercice-d-entrainement-b-ent2-3\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement B.ent2.3<\/h4>\n<p>Soit <code>x<\/code> une variable de type <code>unsigned int<\/code>. Donnez les lignes de code permettant de r\u00e9aliser les calculs suivants en utilisant exclusivement des op\u00e9rations bitwises, i.e., <code>&amp; ~ | ^ &lt;&lt; &gt;&gt;<\/code>. Le r\u00e9sultat doit \u00eatre plac\u00e9 dans la variable <code>x<\/code>.<\/p>\n<p><strong>Q1.<\/strong> Multiplier <code>x<\/code> par 2.<\/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\">x = x &lt;&lt; 1;\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<p><strong>Q2<\/strong>. Diviser <code>x<\/code> par 16.<\/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\">x = x &gt;&gt; 4;\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<p><strong>Q3.<\/strong> Calculer 2 <code>x<\/code> + 1.<\/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\">x = (x &lt;&lt; 1) | 1\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<p><strong>Q4.<\/strong> Calculer 2 \u00e0 la puissance <code>x<\/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\">x = 1 &lt;&lt; x;\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h3><a id=\"it%C3%A9ration-b-ent3\" class=\"anchor\" aria-hidden=\"true\"><\/a>It\u00e9ration B.ent3<\/h3>\n<h4><a id=\"exercice-d-entrainement-b-ent3-1\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement B.ent3.1<\/h4>\n<p>Sans utiliser d&rsquo;ordinateur, donnez les affichages re\u0301alise\u0301s par chacune de ces lignes de code :<\/p>\n<pre><code class=\"language-C\">printf(\"%d \", 32 | 2); \nprintf(\"%x \", 0xF3 &amp; (~ 1));\nprintf(\"%x \", 0xFF &amp; (0xFF &lt;&lt; 1));\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\">34 f2 fe \n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h4><a id=\"exercice-d-entrainement-b-ent3-2\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement B.ent3.2<\/h4>\n<p>On appelle nibbles (ou demi octet) les groupes de 4 bits d&rsquo;un mots binaires. Ces groupes correspondent aussi aux symboles de la repr\u00e9sentation hexad\u00e9cimale d&rsquo;un mot binaire. Par exemple, le mot binaire dont la repr\u00e9sentation hexad\u00e9cimale est 1234 (dans un code source C on l&rsquo;\u00e9crirait 0x1234), et dont la repr\u00e9sentation binaire est 0001 0010 0011 0100, poss\u00e8des 4 nibbles qui sont les mots binaires 0001 0010 0011 0100.<\/p>\n<p>Vous devez r\u00e9aliser une fonction <code>uint16_t rotNibbLeft(uint16_t data)<\/code> qui produit le mot binaire obtenu en r\u00e9alisant une rotation \u00e0 gauche des nibbles du mot binaire d\u00e9sign\u00e9 par le param\u00e8tre <code>data<\/code>.<\/p>\n<p>Pour bien v\u00e9rifier que vous avez compris ce qui est demand\u00e9, essayez de d\u00e9terminer l&rsquo;affichage qui devra \u00eatre produit par ce programme de test.<\/p>\n<pre><code class=\"language-C\">int main()\n{\n    uint16_t data = 0x1234;\n    printf(\"%04X\\n\", rotNibbLeft(data));\n    return 0;\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<pre><code class=\"language-plain_text\">2341\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<p>Vous pouvez maintenant traiter l&rsquo;exercice<\/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\">uint16_t rotNibbLeft(uint16_t data)\n{\n    uint16_t nibbleLeft = data &amp; 0xF000;\n    \/\/ \u00c0 compl\u00e9ter\n}\n<\/code><\/pre>\n<p>La variable <code>nibbleLeft<\/code> est initialis\u00e9e avec le nibble le plus \u00e0 gauche de la donn\u00e9e, c&rsquo;est \u00e0 dire celui qui devra se retrouver \u00e0 droite dans le r\u00e9sultat. Il vous reste \u00e0 construire le r\u00e9sultat \u00e0 partir de ce nibble mis \u00e0 la bonne place et du reste de data d\u00e9cal\u00e9 de mani\u00e8re appropri\u00e9e.<\/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\">uint16_t rotNibbLeft(uint16_t data)\n{\n    uint16_t nibbleLeft = data &amp; 0xF000;\n    return (data &lt;&lt; 4) | (nibbleLeft &gt;&gt; 12); \n}\n<\/code><\/pre>\n<p>Comme toujours, si votre solution diff\u00e8re quelque peu de celle donn\u00e9e ici, testez l\u00e0 sur machine, et en cas de difficult\u00e9 adressez vous \u00e0 une personne enseignante, mais ne restez pas dans le doute.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h4><a id=\"exercice-d-entrainement-b-ent3-3\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice d&rsquo;entrainement B.ent3.3<\/h4>\n<p>Soit <code>x<\/code> une variable de type <code>unsigned int<\/code>. Donnez les lignes de code permettant de r\u00e9aliser les calculs suivants en utilisant exclusivement des op\u00e9rations bitwises, i.e., <code>&amp; ~ | ^ &lt;&lt; &gt;&gt;<\/code>. Le r\u00e9sultat doit \u00eatre plac\u00e9 dans la variable <code>x<\/code>.<\/p>\n<p><strong>Q1.<\/strong> Multiplier <code>x<\/code> par 8.<\/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\">x = x &lt;&lt; 3;\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<p><strong>Q2<\/strong>. Diviser <code>x<\/code> par 4.<\/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\">x = x &gt;&gt; 2;\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<p><strong>Q3.<\/strong> Calculer <code>x<\/code> modulo 2.<\/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\">x = x &amp; 1;\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<p>Soit <code>x<\/code> et <code>y<\/code> deux variables de type <code>unsigned int<\/code>.<\/p>\n<p>Donnez, en fonction de la valeur de <code>x<\/code>, la valeur de <code>y<\/code> apr\u00e8s l&rsquo;ex\u00e9cution de la ligne suivante.<\/p>\n<pre><code class=\"language-C\">y = 3 &lt;&lt; x;\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>\\(3 \\cdot 2^x\\)<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<hr \/>\n<h2><a id=\"activit%C3%A9-de-consolidation-b-top\" class=\"anchor\" aria-hidden=\"true\"><\/a>Activit\u00e9 de consolidation B.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-b-top1\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de consolidation B.top1<\/h3>\n<p>Vous devez r\u00e9aliser une fonction&#8230;<\/p>\n<pre><code class=\"language-c\">unsigned permute(unsigned data, unsigned pos1, unsigned pos2)\n<\/code><\/pre>\n<p>&#8230;qui retourne le mot binaire obtenu en \u00e9changeant les bits situ\u00e9s en positions <code>pos1<\/code> et <code>pos2<\/code> dans <code>data<\/code>.<\/p>\n<p>Les positions des bits sont des entiers non sign\u00e9s. La position 0 correspond au bit le plus \u00e0 droite, comme habituellement. Vous devez utiliser des op\u00e9ration bitwises et non des op\u00e9rations arithm\u00e9tiques. Vous ne devez pas utiliser de boucle.<\/p>\n<p>Commencez par d\u00e9terminer quels devraient \u00eatre les affichages r\u00e9alis\u00e9s par l&rsquo;ex\u00e9cution de la fonction <code>main<\/code> ci-dessous si la fonction <code>permute<\/code> est bien programm\u00e9e.<\/p>\n<pre><code class=\"language-c\">int main()\n{\n    printf(\"%04X\\n\",permute(0xFF00,3,11));\n    printf(\"%04X\\n\",permute(0x00FF,2,12));\n    printf(\"%04X\\n\",permute(0x0000,1,5));\n    printf(\"%04X\\n\",permute(0xFFFF,1,5));\n    return 0;\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<pre><code class=\"language-plain_text\">F708\n10FB\n0000\nFFFF\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<p>Si vous avez bien compris ce que doit r\u00e9aliser la fonction \u00e0 programmer, vous pouvez continuer \u00e0 traiter l&rsquo;exercice.<\/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 le d\u00e9but d&rsquo;une solution.<\/p>\n<pre><code class=\"language-c\">unsigned permute(unsigned data, unsigned pos1, unsigned pos2)\n{\n    unsigned masque1 = 1 &lt;&lt; pos1;\n    unsigned masque2 = 1 &lt;&lt; pos2;\n    \/\/ \u00c0 compl\u00e9ter\n}\n<\/code><\/pre>\n<p>On cr\u00e9e deux masques qui permettront de s\u00e9lectionner les bits situ\u00e9s aux deux positions qui nous int\u00e9ressent. On peut ensuite :<\/p>\n<ul>\n<li>Lire ces bits et conserver leurs valeurs dans des variables.<\/li>\n<li>Mettre \u00e0 0 les bits situ\u00e9s aux positions <code>pos1<\/code> et <code>pos2<\/code> dans <code>data<\/code>.<\/li>\n<li>Cr\u00e9er un nouveau masque permettant, gr\u00e2ce \u00e0 un ou bitwise avec <code>data<\/code>, d&rsquo;obtenir le r\u00e9sultat attendu.<\/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\">Indice 2<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>Voici une version toujours incompl\u00e8te, mais plus avanc\u00e9e de la fonction.<\/p>\n<pre><code class=\"language-c\">unsigned permute(unsigned data, unsigned pos1, unsigned pos2)\n{\n    unsigned masque1 = 1 &lt;&lt; pos1;\n    unsigned masque2 = 1 &lt;&lt; pos2;\n    unsigned bit1 = (data &amp; masque1) &gt;&gt; pos1;\n    unsigned bit2 = (data &amp; masque2) &gt;&gt; pos2;\n    data = data &amp; ~(masque1 | masque2);       \/\/ Ligne A\n    \/\/ \u00c0 compl\u00e9ter\n}\n<\/code><\/pre>\n<p>Dans cette version, on a r\u00e9cup\u00e9r\u00e9 dans les variables <code>bit1<\/code> et <code>bit2<\/code> les valeurs des bits \u00e0 \u00e9changer. Ces variables ont deux valeurs possibles, 0 ou 1, quelles que soient les positions des bits dans <code>data<\/code>.<\/p>\n<p>La ligne A permet de mettre \u00e0 0 les bits situ\u00e9s aux positions <code>pos1<\/code> et <code>pos2<\/code>. Il reste \u00e0 construire et retourner le r\u00e9sultat final.<\/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\">unsigned permute(unsigned data, unsigned pos1, unsigned pos2)\n{\n    unsigned masque1 = 1 &lt;&lt; pos1;\n    unsigned masque2 = 1 &lt;&lt; pos2;\n    unsigned bit1 = (data &amp; masque1) &gt;&gt; pos1;\n    unsigned bit2 = (data &amp; masque2) &gt;&gt; pos2;\n    data = data &amp; ~(masque1 | masque2);\n    return data | (bit1 &lt;&lt; pos2) | (bit2 &lt;&lt; pos1);\n}\n<\/code><\/pre>\n<p>Cette solution n&rsquo;est pas la seule possible. Si vous en avez une autre, faites des v\u00e9rifications pouss\u00e9es de son fonctionnement.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h3><a id=\"exercice-de-consolidation-b-top2\" class=\"anchor\" aria-hidden=\"true\"><\/a>Exercice de consolidation B.top2<\/h3>\n<p>Vous devez r\u00e9aliser une fonction&#8230;<\/p>\n<pre><code class=\"language-c\">int seek(uint32_t data, uint32_t pattern, int n)\n<\/code><\/pre>\n<p>&#8230; qui recherche une suite de bits, constitu\u00e9e des <code>n<\/code> derniers bits de <code>pattern<\/code>, dans un mot binaire appel\u00e9 <code>data<\/code>. La valeur de retour doit \u00eatre la position de la suite de bits recherch\u00e9e dans <code>data<\/code>. D&rsquo;une mani\u00e8re plus g\u00e9n\u00e9rale, la position est le nombre de d\u00e9calages \u00e0 gauche \u00e0 r\u00e9aliser pour faire co\u00efncider la suite de bits recherch\u00e9e avec une suite identique dans <code>data<\/code>. Dans le cas o\u00f9 la suite recherch\u00e9e n&rsquo;appara\u00eet pas dans <code>data<\/code>, la valeur de retour doit \u00eatre -1.<\/p>\n<p>Par exemple, l&rsquo;ex\u00e9cution des lignes de code suivantes&#8230;<\/p>\n<pre><code class=\"language-c\">    uint32_t data = 0b10101111000011001100;\n    uint32_t pattern = 0b1110;\n    printf(\"%d\\n\", seek(data, pattern, 4));\n<\/code><\/pre>\n<p>&#8230;doit produire l&rsquo;affichage 11 parce qu&rsquo;il faut d\u00e9caler les bits de <code>pattern<\/code> de 11 positions pourplacer la s\u00e9quence recherch\u00e9e en face d&rsquo;une s\u00e9quence identique dans <code>data<\/code>.<\/p>\n<pre><code class=\"language-plain_text\">10101111000011001100\n     1110...........\n<\/code><\/pre>\n<p>Quelle est la valeur affich\u00e9e par l&rsquo;ex\u00e9cution des lignes de code suivantes ?<\/p>\n<pre><code class=\"language-c\">    uint32_t data = 0b10101111000011001100;\n    uint32_t pattern = 0b11101;\n    printf(\"%d\\n\", seek(data, pattern, 5));\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 valeur affich\u00e9e doit \u00eatre -1 car la s\u00e9quence recherch\u00e9e n&rsquo;apparait nulle part dans <code>data<\/code>.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<p>Si vous avez bien compris ce qui est attendu, vous pouvez traiter l&rsquo;exercice.<\/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 seek(uint32_t data, uint32_t pattern, int n)\n{\n    uint32_t masque = ~((~0) &lt;&lt; n);  \/\/ Ligne A\n    pattern = pattern &amp; masque;      \/\/ Ligne B\n    \/\/ \u00c0 compl\u00e9ter\n}\n<\/code><\/pre>\n<p>La ligne A cr\u00e9e un masque dont les <code>n<\/code> derniers bits sont \u00e0 1 et les autres \u00e0 0. Ce masque repr\u00e9sente la position possible la plus \u00e0 droite de la s\u00e9quence de bits recherch\u00e9e. Par exemple, si n vaut 5 alors le masque est <code>...00000011111<\/code>.<\/p>\n<p>La ligne B met \u00e0 0 les bits de <code>pattern<\/code> n&rsquo;appartenant pas \u00e0 la s\u00e9quence recherch\u00e9e.<\/p>\n<p>Il reste \u00e0 d\u00e9caler les bits de <code>masque<\/code> et de <code>pattern<\/code> jusqu&rsquo;\u00e0 ce que les bits de pattern co\u00efncident avec les bits de <code>data<\/code> s\u00e9lectionn\u00e9s par le masque.<\/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 2<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-c\">int seek(uint32_t data, uint32_t pattern, int n)\n{\n    uint32_t masque = ~((~0) &lt;&lt; n);\n    pattern = pattern &amp; masque;\n    for(int i=0; i &lt; 32-n; i++)\n    {\n        if( \/* \u00c0 compl\u00e9ter *\/ )\n        {\n            return i;\n        }\n        \/\/\u00a0\u00c0 compl\u00e9ter\n    }\n    return -1;\n}\n<\/code><\/pre>\n<p>Dans cette version encore incompl\u00e8te apparait la boucle permettant d&rsquo;explorer toutes les positions possibles de la s\u00e9quence recherch\u00e9e.<\/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 seek(uint32_t data, uint32_t pattern, int n)\n{\n    uint32_t masque = ~((~0) &lt;&lt; n);\n    pattern = pattern &amp; masque;\n    for(int i=0; i&lt;32-n; i++)\n    {\n        if((data &amp; masque) == pattern)\n        {\n            return i;\n        }\n        masque = masque &lt;&lt; 1;\n        pattern = pattern &lt;&lt; 1;\n    }\n    return -1;\n}\n<\/code><\/pre>\n<p>Voici une solution. Mais il existe un grand nombre d&rsquo;autres impl\u00e9mentations possibles. V\u00e9rifiez votre solution de mani\u00e8re approfondie avec diff\u00e9rentes donn\u00e9es de test. Si vous n&rsquo;avez pas trouv\u00e9 une solution correcte, d\u00e9cortiquez celle propos\u00e9e en vous int\u00e9ressant au r\u00f4le de chaque bloc et en simulant \u00e0 la main son fonctionnement.<\/p>\n<p>Vous pourrez retenter de faire cet exercice sans aide dans au moins une semaine.<\/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. Types primitifs, repr\u00e9sentation binaires, bitwises, bool\u00e9ens 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 [&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-32","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\/32","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=32"}],"version-history":[{"count":3,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/posts\/32\/revisions"}],"predecessor-version":[{"id":91,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/posts\/32\/revisions\/91"}],"wp:attachment":[{"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/media?parent=32"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/categories?post=32"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/tags?post=32"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}