fmaury/coursc
1
0
Fork 0
Code Releases Activity

initial

Browse source
This commit is contained in:
Florian Maury 2014-02-24 18:38:56 +01:00
commit 0b4615ed74
227 changed files with 5555 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

84
CoursC.tex Normal file
View file

@ -0,0 +1,84 @@
\documentclass[handout]{beamer}
\usepackage[utf8x]{inputenc}
\usepackage{default}
\usepackage{color}
\usepackage{hyperref}
\usepackage[french]{babel}
\usepackage[T1]{fontenc}
\usepackage{multirow}
%to use middle vertical alignment
\usepackage{array}
%\usetheme{Boadilla}
%\usecolortheme{whale}
\title{Le Langage C}
\author{Florian Maury}
\institute{3IL}
%suppression de la barre de navigation
\setbeamertemplate{navigation symbols}{}
%Présentation des rappels de sommaire (léger grisement des autres sections, et puce en forme de cercles numérotés
\setbeamertemplate{section in toc shaded}[default][40]
\setbeamertemplate{section in toc}[circle]
\AtBeginSection[]{
\begin{frame}
\begin{center}
\textcolor{blue}{\Huge \secname}
\end{center}
\end{frame}
}
\begin{document}
\begin{frame}
\titlepage
\vspace{0.5cm}
\par
{\footnotesize\begin{center}
\par
\href{http://www.twitter.com/X\_Cli}{\textcolor{blue}{\underline{Twitter}}}
\vspace{0.2cm}
\par
\href{http://www.identi.ca/ixtli}{\textcolor{blue}{\underline{Status.net}}}
\vspace{0.2cm}
\par
\href{mailto:coursc@x-cli.com}{\textcolor{blue}{\underline{Email}}}
\vspace{0.2cm}
\par
\href{svn://c.svn.x-cli.com/ccourse}{\textcolor{blue}{\underline{Sources}}}
\end{center}}
\end{frame}
\begin{frame}
\tableofcontents
\end{frame}
\section{G\'en\'eralit\'es sur le C}
\input{generalites/generalites}
\section{Structure des programmes}
\input{structure/structure}
\section{Les variables}
\input{variables/variables}
\section{Les opérateurs}
\input{operateurs/operateurs}
\section{Branchements}
\input{branchements/branchements}
\section{Pointeurs}
\input{pointeurs/pointeurs}
\end{document}

75
SujetTP2011.tex Normal file
View file

@ -0,0 +1,75 @@
\documentclass[10pt,twocolumn]{article}
\usepackage[utf8]{inputenc}
\usepackage[french]{babel}
\usepackage[T1]{fontenc}
\usepackage{hyperref}
\begin{document}
\title{TP noté - TNI}
\author{Florian Maury}
\date{}
\maketitle
\section{Traitement numérique des images}
Le programme qui est fourni, avec sa mini-bibliothèque, dans l'exercice 1, permet de faire du traitement numérique des images de base.
\par
Les fonctions implémentées permettent :
\begin{description}
\item[generateImage] La génération d'une image aléatoire
\item[getImageMatrix] Le chargement d'une image depuis un fichier Bitmap
\item[setImageMatrix] La sauvegarde d'une image dans un fichier Bitmap
\item[turnGrey] Convertir une image couleur en niveaux de gris
\item[applyThreshold] Effectuer un seuillage d'une image en niveau de gris pour obtenir une image composée uniquement de pixels noirs ou blancs (pas de demi-teintes).
\end{description}
\par
Ces 4 dernières fonctions utilisent une structure nommée \textbf{ImageData} qui contient une matrice d'entier 32 bits, et ses dimensions.
\par
Chaque entier 32 bits représente un pixel de l'image. Les 8 bits de poids le plus fort sont le canal alpha (inutilisé dans ce format de fichier), puis les 8 bits suivants sont pour le rouge, les 8 bits suivant pour le vert, et les 8 bits de poids le plus faible sont pour le bleu.
\par
La matrice est représentée sous un format à une seule dimension. Il est nécessaire de faire de l'arithmétique binaire pour accéder aux cases de la matrice (voir le code de la fonction \textbf{applyThreshold} pour un exemple.
\vspace{2cm}
\par
{\Large \textbf{Instructions de rendu du TP}}
\par
Les fichiers sources doivent être envoyés à fmaury@3il.fr et coursc@x-cli.com avant l'heure indiquée au tableau (à priori 12H).
\section{Exercice 1}
Intégrez les fichiers \href{http://c.x-cli.com/bmphandler.h}{bmphandler.h}, \href{http://c.x-cli.com/bmphandler.cpp}{bmphandler.cpp} et \href{http://c.x-cli.com/tp6main2011.cpp}{main.cpp} à votre projet vide.
Placez le fichier \href{http://c.x-cli.com/image.jpg}{image.bmp} dans le répertoire Debug de votre projet (au niveau d'en dessous vos fichiers .cpp et .h.
Créez un fichier .h qui contiendra les descriptions de vos fonctions et un fichier .c(pp) qui contiendra votre code.
\section{Exercice 2}
Ecrivez et appelez (depuis la fonction main()) une fonction qui créé un duplicata d'une structure ImageData, représentant une image, passée en paramètre. Ce duplicata occupera une zone mémoire différente de la première structure. Effectuez les ajustements nécessaires dans la fonction main().
Cette fonction sera utile pour le reste du TP car les fonctions turnGrey et applyThreshold modifient les matrices et que nous ne souhaitons pas devoir relire dans le fichier à chaque fois qu'on a besoin d'une nouvelle copie de l'image.
\section{Exercice 3}
Ecrivez une fonction qui renvoie une structure ImageData dont toutes les composantes valent 0, sauf l'une d'entre elles. La composante qui n'est pas annulée est spécifiée en paramètre.
Utilisez cette fonction pour sauvegarder sous trois fichiers différents une image avec seulement le rouge, seulement le bleu et seulement le vert, grâce à la fonction setImageMatrix.
\section{Exercice 4}
Ecrivez une fonction qui se base sur applyThreshold pour seuiller uniquement sur le vert (c'est à dire qu'on génère une image uniquement en noir et blanc. Un point est noir si la composante verte est supérieure à une valeur passée en paramètre).
\section{Exercice 5}
Ecrivez une fonction qui effectue l'ouverture d'une image seuillée et renvoie la matrice érodée.
\par
L'ouverture est une opération de traitement numérique des images qui a pour but l'érosion des contours afin d'agrandir les trous.
\par
Pour effectuer cette érosion, on créé une nouvelle matrice vide de taille identique à la matrice d'origine. Chaque pixel vaut 0 si l'un des 4 pixels adjacents (dans l'image d'origine) vaut 0. Un pixel vaut 0xFFFFFFFF si tous les pixels adjacents et lui-même valent 0xFFFFFFFF dans l'image d'origine. Adjacent signifie 4-connexes : le pixel d'au dessus, le pixel d'en dessous, le pixel à gauche, et le pixel à droite.
Les pixels en bordure d'image considèrent que tous les pixels en dehors de l'image valent 0xFFFFFFFF.
\section{Exercice 6}
Ecrivez une fonction qui effectue la fermeture d'une image seuillée et renvoie la matrice re-remplie.
\par
La fermeture est une opération de traitement numérique des images qui a pour but de combler les trous d'une image seuillée.
\par
Pour effectuer ce remplissage, on créé une nouvelle matrice vide de taille identique à la matrice d'origine. Chaque pixel vaut 0xFFFFFFFF si l'un des 4 pixels adjacents ou lui-même (dans l'image d'origine) vaut 0xFFFFFFFF. Un pixel vaut 0 si tous les pixels adjacents et lui-même valent 0 dans l'image d'origine.
Les pixels en bordure d'image considèrent que tous les pixels en dehors de l'image valent 0.
\end{document}

86
TD1.tex Normal file
View file

@ -0,0 +1,86 @@
\documentclass[10pt,twocolumn]{article}
\usepackage[T1]{fontenc}
\usepackage[french]{babel}
\title{TD1}
\author{Florian Maury}
\addtolength{\hoffset}{-1in}
\addtolength{\voffset}{-1.5in}
\setlength{\oddsidemargin}{1cm}
\setlength{\textwidth}{18cm}
\setlength{\headheight}{0pt}
\setlength{\topmargin}{1cm}
\setlength{\textheight}{28cm}
\begin{document}
\maketitle
\section{Exo 1}
Quels types de variable faut-il utiliser dans un environnement embarqu\'e (ressources restreintes) lorsqu'on veut stocker les valeurs suivantes (calculer les valeurs s'il s'agit d'op\'erations math\'ematiques ou logiques):
\begin{itemize}
\item Le num\'ero du jour du mois auquel vous \^etes n\'es ?
\item Le nombre d'\'etudiants \`a 3IL, toutes ann\'ees confondues.
\item Un compteur affichant sur la sortie standard ``0.1, 0.2, 0.3, 0.4''
\item Le solde de votre compte courant
\item true (la valeur bool\'een ``vraie'')
\item 257/3;
\item 1024\%3;
\item 32456789/9;
\item {2, 3.5, 'A', -789};
\item 'A'+3;
\item 127 + 3;
\item chocolat; (\'ecrire la d\'eclaration associ\'ee pour diff\'erentes ``saveurs'')
\item !(245 + 12);
\item 1$<<$10;
\item 255 \& 4;
\item 4 | 127;
\item a==389;
\item 128 \& 2;
\item $\sim$256;
\item 34567544277546 ? 230 : -10;
\item 1024$>$=3
\item 1024$>>$3
\item Votre date de naissance en s\'eparant jour, mois, ann\'ee (mais regroup\'es au sein d'une m\^eme variable)
\item 12376754 ou 2.5
\item Soit un flottant, soit un entier, soit un caract\`ere, soit un bool\'ean, et en plus, dans tous les cas, une \'enum\'eration qui d\'esigne le type de donn\'ee stock\'e dans la premi\`ere partie de ce type.
\item 1$<<$7 + 2
\end{itemize}
\section{Exo 2}
L'extrait de code suivant est il compilable ?
\begin{verbatim}
long lMaVar;
lMaVar = 'z';
\end{verbatim}
\section{Exo 3}
Compl\'etez les op\'erations suivantes pour que la valeur apr\`es le symbole ``=>'' soit retourn\'ee ou donnez la valeur retourn\'ee
\begin{itemize}
\item \verb|4 ... 3 => 7|
\item \verb|4 ... 3 => 0|
\item \verb|... 5 => -6|
\item \verb|char a = 4; ++a + 3 => ...|
\end{itemize}
\section{Exo 4}
Quel est le r\'esultat du code suivant ?
\begin{verbatim}
#include <stdio.h>
int main() {
union { char c; short s; } test;
test.s = 127;
// printf effectue un affichage de type entier
printf(``%d'', test.c);
return 0;
}
\end{verbatim}
\section{Exo 5}
Prouvez par un programme C que -128 ne se code pas 11111111 mais 10000000.
\end{document}

139
TD2.tex Normal file
View file

@ -0,0 +1,139 @@
\documentclass[10pt]{article}
\usepackage[french]{babel}
\usepackage[T1]{fontenc}
\usepackage[utf8]{inputenc}
\addtolength{\hoffset}{-1in}
\addtolength{\voffset}{-1.5in}
\setlength{\oddsidemargin}{1cm}
\setlength{\textwidth}{19cm}
\setlength{\headheight}{0pt}
\setlength{\topmargin}{1cm}
\setlength{\textheight}{27cm}
\pagestyle{empty}
\title{TD 2}
\author{Florian Maury}
\begin{document}
\section{Exercice}
{\small
Soit une fonction ``sigma'' qui retourne la somme de tous les nombres entre 1 et son paramètre.
La fonction retourne 0 en cas d'erreur.
Implémenter cette fonction.
\begin{verbatim}
unsigned int sigma(unsigned short limit);
\end{verbatim}
% Penser aux contrôles d'erreurs si limit < 1
}
\begin{center}
\line(1,0){250}
\end{center}
{\small
Ré-implémenter la même fonction pour le prototype suivant.
\begin{verbatim}
unsigned int sigma(unsigned int limit);
\end{verbatim}
% Penser aux contrôles d'erreurs si limit < 1
%limiter avant la somme UINT_MAX - i > somme : une autre méthode, plus performante serait de calculer la valeur limite ; ici, méthode dynamique meilleure pour raisons didactiques (évolution avec malloc)
}
\section{Exercice}
{\small
Construire une structure permettant d'établir une recette contenant tout ou partie de ces ingrédients.
\begin{itemize}
\item Fromages
\item Champignons
\item Epinards
\item Tomates
\item Oignons
\end{itemize}
}
\begin{center}
\line(1,0){250}
\end{center}
{\small
\'Ecrire une énumération ``Ingredients'' contenant les 5 précédents ingrédients. Il faut que cette énumération permettent de stocker dans une même variable une recette.
}
\begin{center}
\line(1,0){250}
\end{center}
{\small
Implémenter une fonction affichant les ingrédients utilisés pour une recette.
\begin{verbatim}
void showIngredientsFromStucture(struct IngredientsStruct recipe);
\end{verbatim}
}
{\small
Même question pour la fonction suivante~:
\begin{verbatim}
void showIngredientsFromEnum(enum Ingredients recipe);
\end{verbatim}
}
\section{Exercice}
{\small
\'Ecrire une énumération comportant 3 niveaux de TVA (5,5, 7, 19,6).
)
\begin{center}
\line(1,0){250}
\end{center}
{\small
Implémenter la fonction suivante qui applique la TVA à un prix hors-taxe et renvoie le prix avec TVA~:
\begin{verbatim}
unsigned int applyTVA(unsigned int priceExclVTA, enum VTARate rate);
\end{verbatim}
% Penser au dépassement d'integer
}
\section{Exercice}
{\small
\begin{verbatim}
1. Afficher le nom
2. Afficher le prénom
3. Afficher age
4. Quitter
\end{verbatim}
Implémenter une fonction qui affiche le précédent menu et renvoie le numéro de l'option choisie. La valeur renvoyée doit être une valeur valide du menu. Si l'utilisateur ne saisit pas une valeur valide, le programme redemande la saisie. La saisie est effectuée par l'intermédiaire de la fonction suivante~:
\begin{verbatim}
unsigned char getInputFromKeyboard();
\end{verbatim}
Voici le prototype de la fonction à implémenter.
\begin{verbatim}
unsigned char displayAndSelectOptions();
\end{verbatim}
}
\begin{center}
\line(1,0){250}
\end{center}
{\small
Implémenter une fonction qui affiche ``Doe'' si l'option 1 est choisie, ``John'' si l'option est choisie, ``42 ans'' si l'option 3 est choisie, et ``Erreur'' en cas d'autre valeur.
Voici son prototype.
\begin{verbatim}
void displayPersonalData(unsigned char input);
\end{verbatim}
}
\end{document}

183
TD3.tex Normal file
View file

@ -0,0 +1,183 @@
\documentclass[10pt]{article}
\usepackage[french]{babel}
\usepackage[T1]{fontenc}
\usepackage[utf8]{inputenc}
\usepackage{acronym}
\addtolength{\hoffset}{-1in}
\addtolength{\voffset}{-1.5in}
\setlength{\oddsidemargin}{1cm}
\setlength{\textwidth}{19cm}
\setlength{\headheight}{0pt}
\setlength{\topmargin}{1cm}
\setlength{\textheight}{27cm}
\pagestyle{empty}
\title{TD 3}
\author{Florian Maury}
\begin{document}
\section{Exercice}
\'Ecrire une fonction qui renvoie une structure contenant le quotient et le reste d'une division de son premier argument par son second. Déclarer la structure utilisée.
\begin{verbatim}
struct div_t {
int q;
int r;
};
struct div_t divide(int leftOperand, int rightOperand) {
struct div_t result;
result.q = leftOperand / rightOperand;
result.r = leftOperand % rightOperand;
return result;
}
\end{verbatim}
\section{Exercice}
\'Ecrire 3 fonctions safeAdd, safeSub, safeMul qui permettent d'effectuer des opérations de calcul sans risque de dépassement sur des int.
Si un integer overflow survient, ces fonctions mettent à 1 une variable globale "g\_iComputeError".
Si aucun dépassement n'intervient, la variable vaut 0.
\begin{verbatim}
int safeAdd(int leftOperand, int rightOperand) {
if ((leftOperand > 0 && rightOperand > 0 && leftOperand > INT_MAX - rightOperand) ||
(leftOperand < 0 && rightOperand < 0 && leftOperand < INT_MIN - rightOperand)) {
g_iComputeError = 1;
}
else {
g_iComputeError = 0;
}
return leftOperand + rightOperand;
}
int safeSub(int leftOperand, int rightOperand) {
if ((leftOperand > 0 && rightOperand < 0 && leftOperand > INT_MAX + rightOperand) ||
(leftOperand < 0 && rightOperand > 0 && leftOperand < INT_MIN + rightOperand)) {
g_iComputeError = 1;
}
else {
g_iComputeError = 0;
}
return leftOperand - rightOperand;
}
int safeMul(int leftOperand, int rightOperand) {
if (((leftOperand > 0 && rightOperand > 0 ) && leftOperand > INT_MAX / rightOperand)||
((leftOperand < 0 && rightOperand < 0 ) && leftOperand < INT_MAX / rightOperand) ||
((leftOperand > 0 && rightOperand < 0 ) && leftOperand > INT_MIN / rightOperand) ||
((leftOperand < 0 && rightOperand > 0 ) && leftOperand < INT_MIN / rightOperand)) {
g_iComputeError = 1;
}
else {
g_iComputeError = 0;
}
return leftOperand * rightOperand;
}
\end{verbatim}
\section{Exercice}
Déclarer et implémenter une fonction qui calcule le \ac{PGCD} de deux nombres.
L'algorithme est le suivant :
\begin{verbatim}
Fonction pgcd (a: Entier, b: Entier) : Entier
Tant que b est différent de 0:
a reçoit la valeur de b
b reçoit l'ancienne valeur de a modulo b
Renvoyer a
Fin fonction pgcd
\end{verbatim}
\begin{verbatim}
int pgcd(int a, int b) {
int tmp;
while(b != 0) {
tmp = a;
a = b;
b = tmp % b;
}
return a;
}
\end{verbatim}
\section{Exercice}
Implémenter la fonction suivante :
\begin{verbatim}
int exercice(int arg1, int arg2);
\end{verbatim}
Voici ce que doit faire cette fonction (dans l'ordre de priorité) :
\begin{enumerate}
\item Si arg1 xor arg2 vaut 2, la valeur renvoyée est $-1$.
\item Si arg2 est égal à 1, alors on considère que arg1 est formé de deux entiers 16 bits concaténés : on renvoie alors la valeur stockée dans les 16 bits de poids le plus fort de arg1.
\item Si arg2 est égal à 2, et arg1 est positif, la valeur renvoyée est le factoriel de arg1.
\item Si arg1 divise arg2 et que le reste est nul, alors la valeur renvoyée est un entier dont les 16 bits de poids le plus fort sont constitués des 16 bits de poids le plus fort de arg1 et ses 16 bits de poids le plus faible des 16 bits de poids le plus faible d'arg2.
\item Cette fonction renvoie la somme de ses deux arguments si arg1 est inférieur à 10 et arg2 supérieur à 15
\item Elle renvoie la multiplication des deux arguments si arg1 est un multiple de 15 et est strictement positif.
\item Si aucun de ces cas n'est appliqué, alors la valeur renvoyée est $-2$
\end{enumerate}
Vous devez renvoyer 0 si un dépassement d'entier (integer overflow) intervient pendant l'un de ces calculs.
La fonction ne doit avoir qu'une seule instruction return.
%Cas 1: 5 7 => -1
%Cas 2: 196608 1 => 3
%Cas 3: 5 2 => 120
%Cas 4: 65540 10 => 65546
%Cas 5: -30 16 => -14
%Cas 6: 90 4 => 360
%Cas 7: 89 4 => -2
\begin{verbatim}
int exercice(int arg1, int arg2) {
int result;
if((arg1 ^ arg2) == 2) {
result = -1;
}
else if(arg2 == 1) {
result = arg1 >> 16;
}
else if(arg2 == 2 && arg1 > 0) {
result = 1;
for(int i = 2 ; i <= arg1 ; i++) {
result = safeMul(result, i);
if(g_iComputeError) {
result = 0;
break;
}
}
}
else if(arg1 % arg2 == 0) {
result = (arg1 & ~((1 << 16) - 1)) + (arg2 & ((1 << 16) - 1));
}
else if(arg1 < 10 && arg2 > 15) {
result = safeAdd(arg1, arg2);
if(g_iComputeError) {
result = 0;
}
}
else if(arg1 % 15 == 0 && arg1 > 0) {
result = safeMul(arg1, arg2);
if(g_iComputeError) {
result = 0;
}
}
else {
result = -2;
}
return result;
}
\end{verbatim}
\begin{acronym}
\acro{PGCD}{Plus Grand Commun Diviseur}
\end{acronym}
\end{document}

88
TP1-2011.tex Normal file
View file

@ -0,0 +1,88 @@
\documentclass[11pt]{article}
\usepackage[french]{babel}
\usepackage[T1]{fontenc}
\usepackage[utf8]{inputenc}
\addtolength{\hoffset}{-1in}
\addtolength{\voffset}{-1.5in}
\setlength{\oddsidemargin}{1cm}
\setlength{\textwidth}{19cm}
\setlength{\headheight}{0pt}
\setlength{\topmargin}{1cm}
\setlength{\textheight}{27cm}
\pagestyle{empty}
\title{TP 1}
\author{Florian Maury}
\begin{document}
\maketitle
\section{Démarrer avec Visual Studio 2010}
\begin{enumerate}
\item Démarrer Visual Studio C++ 2010
\item Choisir C++
\item Créer un projet par programme/exercice
\item Fichier -> Nouveau -> Projet -> Projet vide
\item Sur ``fichiers sources'', clic-droit -> ajouter -> fichier -> fichier .cpp
\end{enumerate}
\section{Exercice}
\'Ecrire un programme permettant de calculer le reste de la division d'un premier nombre par un second. \\
Vous devez coder cette fonctionnalité en utilisation ni / ni \%. \\
Tous les cas doivent être envisagés.
\par
Pour saisir les deux nombres, vous pouvez déclarer deux \verb|int|, et utiliser \verb|scanf()| de la façon suivante~:
\begin{verbatim}
int leftOperand, rightOperand, result, reminder;
scanf("%d", &leftOperand);
scanf("%d", &rightOperand);
\end{verbatim}
\par
L'affichage de la réponse peut être fait avec le code suivant~:
\begin{verbatim}
printf("%d divisé par %d donne %d et un reste de %d\n", leftOperand, rightOperand, result, reminder);
\end{verbatim}
Les fonctions \verb|printf()| et \verb|scanf()| nécessitent l'inclusion de la bibliothèque $<$stdio.h$>$.
\section{Exercice~: Jeu de la puce}
Une puce se déplace linéairement et toujours dans le même sens. Elle part de la position zéro. Sur son déplacement, des trous sont placés aux positions multiples de 7 et aux positions multiples de 3. Le joueur doit saisir la longueur du saut qui devra être comprise en 1 et 9 inclus. La partie s’achève lorsque la puce tombe dans un trou (partie perdue) ou lorsqu’elle a réussi à faire 10 sauts sans tomber (partie gagnée). Ecrire l’algorithme de ce petit jeu en prenant soin de ne pas afficher la position courante de la puce, mais en inscrivant à chaque itération le nombre de saut. Veillez à ce que l’utilisateur ne puisse saisir de valeurs incohérentes.
\section{Exercice}
Le programme suivant comporte une boucle infinie. Mais lors de l’exécution celui-ci s’arrête.
\begin{verbatim}
#include <stdio.h>
int main() { int i;
i=1;
do { i=2*i;
} while (i<2*i); printf("i=%d\t2*i=%d\n",i,2*i);
}
\end{verbatim}
\begin{enumerate}
\item Taper et exécuter ce programme.
\item Pourquoi l’exécution se termine-t-elle ?
\item En déduire un programme pour déterminer la plus grande et la plus petite valeur que l’on peut stocker dans le type int.
\item Quels sont ces valeurs ?
\item Quel est le temps d’exécution de ce programme ? (utiliser la bibliothèque $<$windows.h$>$)
\item Proposer un second programme basé sur celui que vous venez de réaliser pour augmenter son efficacité.
\end{enumerate}
\section{Exercice~: Les montagnes russes}
Ecrire un programme qui génère l’affichage suivant :
\begin{verbatim} * * *
*** *** ***
***** ***** ***** *********************
\end{verbatim} Proposer une version qui demande à l’utilisateur le caractère à afficher, la hauteur des montagnes et le nombre de sommets.
\end{document}

286
TP2.tex Normal file
View file

@ -0,0 +1,286 @@
\documentclass[10pt]{article}
\usepackage[french]{babel}
\usepackage[T1]{fontenc}
\usepackage[utf8]{inputenc}
\usepackage{acronym}
\addtolength{\hoffset}{-1in}
\addtolength{\voffset}{-1.5in}
\setlength{\oddsidemargin}{1cm}
\setlength{\textwidth}{19cm}
\setlength{\headheight}{0pt}
\setlength{\topmargin}{1cm}
\setlength{\textheight}{27cm}
\pagestyle{empty}
\title{TP 2}
\author{Florian Maury}
\begin{document}
\section{LFSR~: écriture d'un générateur de nombres pseudo-aléatoires}
\begin{verbatim}
bool getRandomBit(unsigned short seed);
\end{verbatim}
La fonction getRandomBit() peut être appelée de deux manières différentes~:
\begin{itemize}
\item Son paramètre est non nul~: dans ce cas, le ``registre'' du générateur est initialisé avec la valeur fournie en paramètre
\item Son paramètre est nul~: le générateur utilise la valeur contenue actuellement dans le ``registre''
\end{itemize}
Le registre est une variable statique locale à la fonction getRandomBit() car la valeur doit être préservée d'un appel sur l'autre de la fonction.
Cette fonction utilise l'implémentation de Fibonacci de LFSR.
A chaque appel, la fonction initialise le registre avec la valeur fournie en paramètre si elle est non nulle.
Elle sauve ensuite la valeur du bit de poids le plus faible du registre. C'est cette valeur qui sera renvoyée par la fonction à la fin du traitement.
Les bits aux rangs 0, 2, 3, et 5 (le bit de poids le plus fort est de rang 15 et celui de poids le plus faible 0) sont XORés ensembles.
Le registre est alors décalé (binairement) une fois à droite. Le bit généré par les XORs est OR avec le bit de poids le plus fort.
\subsection{Correction}
\begin{verbatim}
bool getRandomBit(unsigned short seed) {
static unsigned short s = 0;
bool bGeneratedBit;
// Seeding the generator
if(s == 0) {
if(seed == 0) {
s = (unsigned short) time(NULL);
}
else {
s = seed;
}
} else if (seed != 0) {
s = seed;
}
//bGeneratedBit = s >> 15 & 1;
//s = (s << 1) | ( ( ((s>>15) & 1) ^ ((s>>13) & 1) ^ ((s>>12) & 1) ^ ((s>>10) & 1)) & 1 );
bGeneratedBit = s & 1;
s = (s >> 1) | ( ((s & 1) ^ ((s >> 2) & 1) ^ ((s >> 3) & 1) ^ ((s >> 5) & 1)) << 15);
return bGeneratedBit;
}
\end{verbatim}
\section{Générer un int pseudo-aléatoire}
\'Ecrire un programme qui génère un entier 32 bits non signé pseudo-aléatoire à l'aide de la fonction getRandomBit précédemment écrite, initialisée avec le seed ``0x4242'' et l'affiche à l'écran à l'aide de la ligne suivante~:
\begin{verbatim}
printf("%d\n", entierAleatoire);
\end{verbatim}
\subsection{Correction}
\begin{verbatim}
int main() {
unsigned int iRandomValue = (unsigned int) getRandomBit(INIT_VALUE);
for(int i = 1 ; i < 32 ; i++) {
iRandomValue = (iRandomValue<<1) | (unsigned int) getRandomBit(0);
}
printf("%d\n", iRandomValue);
return 0;
}
\end{verbatim}
\section{Fonction getRandomInt}
\'Ecrire une fonction qui renvoie un entier 32 bits pseudo-aléatoire. Cette fonction doit être une généralisation de la fonction du premier exercice.
La solution doit être plus performante que générer 32 bits en faisant 32 appels à getRandomBit (en gros, faut utiliser une boucle\ldots).
\subsection{Correction}
\begin{verbatim}
unsigned int getRandomInt(unsigned short seed) {
static unsigned short s = 0;
unsigned int iGeneratedInt = 0;
// Seeding the generator
if(s == 0) {
if(seed == 0) {
s = (unsigned short) (time(NULL));
printf("init with time: %d\n", s);
}
else {
s = seed;
}
} else if (seed != 0) {
s = seed;
}
for(int i = 0 ; i < 32 ; i++) {
iGeneratedInt = (iGeneratedInt << 1) | (s & 1);
s = (s >> 1) | ( ((s & 1) ^ ((s >> 2) & 1) ^ ((s >> 3) & 1) ^ ((s >> 5) & 1)) << 15);
//iGeneratedInt = (iGeneratedInt << 1) | ((s >> 15) & 1);
//s = (s << 1) | ( ( ((s>>15) & 1) ^ ((s>>13) & 1) ^ ((s>>12) & 1) ^ ((s>>10) & 1)) & 1 );
}
return iGeneratedInt;
}
\end{verbatim}
\section{Jouer avec la génération pseudo-aléatoire}
\'Ecrire un programme qui génère un unsigned char aléatoire. Le programme vous propose ensuite de saisir au clavier une valeur entre 0 et 255 et vous indique si votre saisie est plus grande ou moins grande que le nombre pseudo-aléatoire. Si votre saisie est égale au nombre pseudo aléatoire, le programme vous affiche le message "Victoire" et quitte.
Pour rendre le jeu intéressant, initialiser le générateur pseudo-aléatoire avec le résultat de la fonction time() (casté en unsigned short) de la bibliothèque $<$time.h$>$
\par
La saisie au clavier se fait à l'aide de la ligne suivante. La variable ``input'' doit être de type short !
\begin{verbatim}
fflush(stdin);
scanf("%hd", &input);
\end{verbatim}
\subsection{Correction}
\begin{verbatim}
int main() {
unsigned char ucToFind = getRandomUChar(0);
short sGuess;
printf("Cheatcode: %d\n", ucToFind);
do {
do {
puts("Try to guess:");
fflush(stdin);
scanf("%hd", &sGuess);
} while(sGuess < 0 || sGuess > 255);
if(sGuess < ucToFind) {
puts("Too low");
}
else if(sGuess > ucToFind) {
puts("Too high");
}
} while(sGuess != ucToFind);
puts("Victoire !!");
return 0;
}
\end{verbatim}
%\section{Décoder le message secret}
%\'Ecrire un programme qui demande des entiers 32 bits pseudo-aléatoires (initialisation avec 0x4242) et les XOR avec des valeurs saisies au clavier. Ces valeurs sont des int, saisis avec la ligne de commande suivante :
%\begin{verbatim}
%fflush(stdin);
%scanf("%d", &input);
%\end{verbatim}
%
%Afficher le résultat du XOR avec la ligne de commande suivante~:
%\begin{verbatim}
%printf("%c%c%c%c\n", (input>>24), ((input >> 16) & ((1<<8) - 1)), ((input >> 8) & ((1<<8) - 1)), (input & ((1<<8) - 1)));
%\end{verbatim}
%
%Voici la liste des entiers à saisie au clavier~:
%\begin{itemize}
% \item 123
%\end{itemize}
%#ifndef __cplusplus
%#include <stdbool.h>
%#endif
%
%#include <stdio.h>
%#include <time.h>
%#include <stdlib.h>
%#define INIT_VALUE 0x4242
%
%bool getRandomBit(unsigned short seed) {
% static unsigned short s = 0;
% bool bGeneratedBit;
%
% // Seeding the generator
% if(s == 0) {
% if(seed == 0) {
% s = (unsigned short) time(NULL);
% }
% else {
% s = seed;
% }
% } else if (seed != 0) {
% s = seed;
% }
%
% bGeneratedBit = s >> 15 & 1;
% s = (s << 1) | ( ( ((s>>15) & 1) ^ ((s>>13) & 1) ^ ((s>>12) & 1) ^ ((s>>10) & 1)) & 1 );
% return bGeneratedBit;
%}
%
%int getRandomInt(unsigned short seed) {
% static unsigned short s = 0;
% int iGeneratedInt = 0;
%
% // Seeding the generator
% if(s == 0) {
% if(seed == 0) {
% printf("init with time");
% s = (unsigned short) time(NULL);
% }
% else {
% s = seed;
% }
% } else if (seed != 0) {
% s = seed;
% }
%
% for(int i = 0 ; i < 32 ; i++) {
% //iGeneratedInt = (iGeneratedInt << 1) | (s & 1);
% iGeneratedInt = (iGeneratedInt << 1) | ((s >> 15) & 1);
% s = (s << 1) | ( ( ((s>>15) & 1) ^ ((s>>13) & 1) ^ ((s>>12) & 1) ^ ((s>>10) & 1)) & 1 );
% // s = (s >> 1) | ( ( ((s>>15) & 1) ^ ((s>>13) & 1) ^ ((s>>12) & 1) ^ ((s>>10) & 1) ^ (s & 1) ) << 15 );
% }
% return iGeneratedInt;
%}
%
%unsigned char getRandomUChar(unsigned short seed) {
% static unsigned short s = 0;
% unsigned char ucGeneratedUChar = 0;
%
% // Seeding the generator
% if(s == 0) {
% if(seed == 0) {
% s = (unsigned short) (time(NULL));
% printf("init with time: %d\n", s);
% }
% else {
% s = seed;
% }
% } else if (seed != 0) {
% s = seed;
% }
%
% for(int i = 0 ; i < 32 ; i++) {
% ucGeneratedUChar = (ucGeneratedUChar << 1) | ((s >> 15) & 1);
% s = (s << 1) | ( ( ((s>>15) & 1) ^ ((s>>13) & 1) ^ ((s>>12) & 1) ^ ((s>>10) & 1)) & 1 );
% }
% return ucGeneratedUChar;
%}
%
%int main() {
% unsigned char ucToFind = getRandomUChar(0);
% short sGuess;
% unsigned int iRandomValue = (unsigned int) getRandomBit(INIT_VALUE);
% for(int i = 1 ; i < 32 ; i++) {
% iRandomValue = (iRandomValue<<1) | (unsigned int) getRandomBit(0);
% }
% printf("%d\n", iRandomValue);
% printf("%d\n", getRandomInt(INIT_VALUE));
% printf("%d\n", getRandomInt(0x1010));
% printf("%d\n", getRandomInt(0));
%
%
% printf("Cheatcode: %d\n", ucToFind);
% do {
% do {
% puts("Try to guess:");
% fflush(stdin);
% scanf("%hd", &sGuess);
% } while(sGuess < 0 || sGuess > 255);
% if(sGuess < ucToFind) {
% puts("Too low");
% }
% else if(sGuess > ucToFind) {
% puts("Too high");
% }
% } while(sGuess != ucToFind);
% puts("Victoire !!");
% return 0;
%}
\end{document}

21
branchements/01.tex Normal file
View file

@ -0,0 +1,21 @@
\begin{frame}[containsverbatim]
\frametitle{\secname}
\framesubtitle{\subsecname~: if~I}
Il est possible de diviser le flot d'exécution en branches distinctes suivant une condition~: une expression évaluée à vrai ou faux.
\begin{block}{Syntaxe générale d'un block if}
\begin{verbatim}
// instructions 1
if( expression ) {
// instructions 2
}
// instructions 3\end{verbatim}
\end{block}
\par
Une fois les instructions ``instructions 1'' exécutées, l'expression entre parenthèses est évaluée.
\par
Si elle s'avère vraie, alors les instructions ``instructions 2'' sont exécutées à leur tour, puis les instructions ``instructions 3'' le sont également.
\par
Si la condition s'avère fausse, alors les instructions ``instructions 2'' NE sont PAS exécutées puis les instructions ``instructions 3'' sont exécutées.
\end{frame}

17
branchements/02.tex Normal file
View file

@ -0,0 +1,17 @@
\begin{frame}[containsverbatim]
\frametitle{\secname}
\framesubtitle{\subsecname~: if~II}
\begin{exampleblock}{Exemple d'utilisation d'un if}
\begin{verbatim}
void exemple(int v) {
puts("Je suis une instruction toujours exécutées.");
if (v < 5) {
puts("Je suis exécutée si v est inférieur à 5);
}
puts("Je suis tjs exécutée, quelque soit la valeur de v");
}\end{verbatim}
\end{exampleblock}
\end{frame}

24
branchements/03.tex Normal file
View file

@ -0,0 +1,24 @@
\begin{frame}[containsverbatim]
\frametitle{\secname}
\framesubtitle{\subsecname~: if~III}
Si parmi les instructions du block \verb|if| se trouvent des instructions mettant fin à un flot d'instructions, alors le code ``instructions 3'' n'est
pas exécutés.
{\small\begin{exampleblock}{Exemple d'interruption de fonction dans un block if}
\begin{verbatim}
int fonctionDeTest(int v) {
puts("Toujours exécuté");
if( v < 5 ) {
puts("V est inférieur à 5");
return true; // sortie de fonction immédiate !
}
puts("Exécuté que si v n'est pas < à 5.");
return false; // sortie de fonction immédiate !
}\end{verbatim}
\end{exampleblock}}
\vspace{0.3cm}
\par
D'autres instructions telles que \verb|break|, \verb|continue|, ou des appels à des fonctions mettant fin au programme, tels que \verb|exit()| ou \verb|abort()|
peuvent interrompre une fonction lors de son exécution.
\end{frame}

17
branchements/04.tex Normal file
View file

@ -0,0 +1,17 @@
\begin{frame}
\frametitle{\secname}
\framesubtitle{\subsecname~: if~IV}
\begin{alertblock}{Importance de la cohérence dans les branchements}
Il est essentiel que les différentes branches logiques d'un programme restent cohérentes entre elles.
\vspace{0.3cm}
\par
Si une fonction doit retourner une valeur, toutes vos branches logiques doivent retourner une valeur.
\vspace{0.3cm}
\par
Si une variable est utilisée après des branchements logiques qui l'initialisent, vous devez vous assurer qu'il n'existe pas un cas de figure dans
lequel la variable parvient à être utilisée sans avoir été précédemment initialisée.
\end{alertblock}
\end{frame}

23
branchements/05.tex Normal file
View file

@ -0,0 +1,23 @@
\begin{frame}[containsverbatim]
\frametitle{\secname}
\framesubtitle{\subsecname~: if~V}
{\small\begin{exampleblock}{Deux utilisations incorrectes du branchement if}
\begin{verbatim}
int exemple(int v) {
if(v < 5) {
return -1;
}
puts("Branchement sans return !");
}
int exemple2(int v) {
int result;
if(v < 5) {
result = -1;
}
puts("result pas toujours initialisé !");
return result;
}\end{verbatim}
\end{exampleblock}}
\end{frame}

21
branchements/06.tex Normal file
View file

@ -0,0 +1,21 @@
\begin{frame}[containsverbatim]
\frametitle{\secname}
\framesubtitle{\subsecname~: if-else~I}
Une variante du block \verb|if| est le branchement conditionnel \verb|if-else|.
\vspace{0.3cm}
\par
Dans cette variante, si et seulement si l'expression/condition est évaluée à faux, les instructions contenues dans le block \verb|else| sont exécutées.
\begin{block}{Syntaxe générale du groupement if-else}
\begin{verbatim}
// instructions 1
if (expression) {
// instructions 2
}
else {
// instructions 3
}
// instruction 4\end{verbatim}
\end{block}
\end{frame}

19
branchements/07.tex Normal file
View file

@ -0,0 +1,19 @@
\begin{frame}[containsverbatim]
\frametitle{\secname}
\framesubtitle{\subsecname~: if-else~II}
\begin{exampleblock}{Exemple d'utilisation des branchements conditionnels if-else}
\begin{verbatim}
void exemple(int v) {
puts("Tjs exécutée");
if(v < 5) {
puts("Executée si v < 5");
}
else {
puts("Executée si v >= 5);
}
puts("Tjs exécutée");
}\end{verbatim}
\end{exampleblock}
\end{frame}

24
branchements/08.tex Normal file
View file

@ -0,0 +1,24 @@
\begin{frame}[containsverbatim]
\frametitle{\secname}
\framesubtitle{\subsecname~: Imbrications}
Les blocks \verb|if| et \verb|if-else| peuvent être imbriqués à volonté, autant de fois que nécessaire, sans restriction spécifique.
{\footnotesize\begin{exampleblock}{Imbrication de blocks if et ses variantes}
\begin{verbatim}
if(a < 5) {
//instructions
if(a > -50) {
//instructions
}
else {
//instructions
}
else {
if(b == 2) {
//instructions
}
//instructions
}\end{verbatim}
\end{exampleblock}}
\end{frame}

22
branchements/09.tex Normal file
View file

@ -0,0 +1,22 @@
\begin{frame}[containsverbatim]
\frametitle{\secname}
\framesubtitle{\subsecname~: else if~I}
Si l'unique instruction d'un block \verb|else| est un block \verb|if| contenant un nombre arbitraire d'instructions alors il est possible de le formuler de
manière plus compacte avec \verb|else if|.
{\small\begin{exampleblock}{Exemple de block else contenant juste un if}
\begin{verbatim}
if(condition1) {
//instructions 1
}
else {
if{condition2) {
//instructions 2
}
else {
//instructions 3
}
}\end{verbatim}
\end{exampleblock}}
\end{frame}

21
branchements/10.tex Normal file
View file

@ -0,0 +1,21 @@
\begin{frame}[containsverbatim]
\frametitle{\secname}
\framesubtitle{\subsecname~: else if~II}
L'exemple précédent peut être compacté en~:
\begin{exampleblock}{Compactage grâce au block else if}
\begin{verbatim}
if(condition1) {
//instructions 1
}
else if (condition 2) {
//instructions 2
}
else {
//instructions 3
}\end{verbatim}
\end{exampleblock}
\par
Il est possible de chainer autant de block \verb|else if| que nécessaire.
\end{frame}

21
branchements/11.tex Normal file
View file

@ -0,0 +1,21 @@
\begin{frame}[containsverbatim]
\frametitle{\secname}
\framesubtitle{\subsecname~: if imbriqués}
Si la seule instruction d'un block if (sans else) est un if (sans else), alors ils peuvent être compactés en un seul if dont les deux conditions sont fusionnées à l'aide de l'opérateur \&\& (ET logique).
\begin{exampleblock}{Exemple de deux blocks if compactables}
\begin{verbatim}
if(condition1) {
if(condition2) {
//instructions
}
}\end{verbatim}
\end{exampleblock}
\begin{exampleblock}{Compactage des deux if}
\begin{verbatim}
if(condition1 && condition2) {
//instructions
}\end{verbatim}
\end{exampleblock}
\end{frame}

22
branchements/12.tex Normal file
View file

@ -0,0 +1,22 @@
\begin{frame}[containsverbatim]
\frametitle{\secname}
\framesubtitle{\subsecname~: Code mort}
\begin{alertblock}{Attention au code mort}
Les branchements conditionnels peuvent devenir vite complexes à force d'imbrication. Il faut alors veiller à ne pas créer du \textbf{code mort}.
\vspace{0.3cm}
\par
Du code mort est du code qui ne sera jamais exécuté, quoiqu'il arrive. Ce cas intervient notamment si la condition décidant si une série d'instructions est exécutée
ne peut jamais devenir vraie. La détection de ce code n'est pas toujours triviale comme dans l'exemple ci-dessous.
\end{alertblock}
{\footnotesize\begin{exampleblock}{Exemple de code mort}
\begin{verbatim}
if(a < 5) {
if(a > 50) {
//ce code ne sera jamais exécuté
}
// instructions
}\end{verbatim}
\end{exampleblock}}
\end{frame}

24
branchements/13.tex Normal file
View file

@ -0,0 +1,24 @@
\begin{frame}[containsverbatim]
\frametitle{\secname}
\framesubtitle{\subsecname~I}
Il arrive parfois qu'on teste une même variable contre plusieurs valeurs potentielles. Pour cela, on peut chainer un \verb|if| suivi d'un nombre arbitraire de
\verb|else if| pour finir optionnellement par un \verb|else| (le cas par défaut).
{\footnotesize\begin{exampleblock}{Test d'une même variable contre plusieurs valeurs}
\begin{verbatim}
void testVal(int a) {
if(a == 0) {
//instructions 1
} else if(a == 1) {
//instructions 2
} else if(a == 2) {
... // signifie une ellipse dans l'exemple
} else if(a == 19) {
//instructions 20
} else {
//instructions 21 (cas par défaut)
}
}\end{verbatim}
\end{exampleblock}}
\end{frame}

24
branchements/14.tex Normal file
View file

@ -0,0 +1,24 @@
\begin{frame}[containsverbatim]
\frametitle{\secname}
\framesubtitle{\subsecname~II}
Le code précédent est lourd et peu lisible.
\vspace{0.3cm}
\par
\verb|switch| est une construction conditionnelle permettant d'effectuer le même genre d'opérations avec une syntaxe plus simple.
{\footnotesize\begin{block}{Syntaxe générale du switch}
\begin{verbatim}
switch(expression) {
case UNE_CONSTANTE:
//instructions 1
break;
case UNE_AUTRE_CONSTANTE:
//instructions 2
break;
default:
//instructions par défaut
break;
}\end{verbatim}
\end{block}}
\end{frame}

26
branchements/15.tex Normal file
View file

@ -0,0 +1,26 @@
\begin{frame}[containsverbatim]
\frametitle{\secname}
\framesubtitle{\subsecname~III}
{\footnotesize\begin{exampleblock}{Conversion des if-else if-else en switch}
\begin{verbatim}
void testVal(int a) {
switch(a) {
case 0:
//instructions 1
break;
case 1:
//instructions 2
break;
... // signifie une ellipse dans l'exemple
case 19:
//instructions 20
break;
default:
//instructions 21
break;
}
}\end{verbatim}
\end{exampleblock}}
\end{frame}

20
branchements/16.tex Normal file
View file

@ -0,0 +1,20 @@
\begin{frame}[containsverbatim]
\frametitle{\secname}
\framesubtitle{\subsecname~IV}
L'expression en paramètre du \verb|switch| est testée contre les valeurs constantes de chaque \verb|case|.
\vspace{0.3cm}
\par
Lorsque la constante est égale à la variable testée, le code suivant le \verb|case| sélectionné est exécuté, jusqu'à rencontrer une instruction \verb|break|.
\par
\verb|break| signifie la sortie immédiate du block du \verb|switch|. La prochaine instruction exécutée est alors le code suivant immédiatement le block \verb|switch|.
\vspace{0.3cm}
\par
Si aucune constante n'est égale à l'expression testée, le cas \verb|default| est exécuté, s'il existe. Si aucun cas \verb|default| n'a été déclaré, alors aucun code du
block switch n'est exécuté.
\vspace{0.3cm}
\par
Seules des constantes entières peuvent suivre le mot-clé \verb|case|. Ces constantes peuvent être des variables déclarées constantes (y compris des membres d'énumérations),
des constantes littérales ou des macros se résolvant en constantes littérales.
\end{frame}

10
branchements/17.tex Normal file
View file

@ -0,0 +1,10 @@
\begin{frame}[containsverbatim]
\frametitle{\secname}
\framesubtitle{\subsecname~V}
\begin{alertblock}{Cohérence, code mort, \ldots}
Attention ! Les mêmes précautions que pour la famille des blocks if doivent être respectées, que ce soit en terme de code mort, ou de cohérence en cas d'initialisation
de variables, d'instructions \verb|return|\ldots
\end{alertblock}
\end{frame}

23
branchements/18.tex Normal file
View file

@ -0,0 +1,23 @@
\begin{frame}[containsverbatim]
\frametitle{\secname}
\framesubtitle{\subsecname~VI}
{\footnotesize\begin{exampleblock}{Exemple incorrect}
\begin{verbatim}
int exemple(int a) {
if(a < 0) {
return 0;
}
switch(a) {
case -1:
return 1; // code mort
break;
case 1:
return 2;
break;
}
}\end{verbatim}
\end{exampleblock}}
Si \verb|a| n'est pas négatif, ni égal à 1, la fonction n'exécute pas d'instruction \verb|return| (ce qui est une faute de programmation) !
\end{frame}

25
branchements/19.tex Normal file
View file

@ -0,0 +1,25 @@
\begin{frame}[containsverbatim]
\frametitle{\secname}
\framesubtitle{\subsecname~VII}
Si un \verb|case| ne se termine pas par un \verb|break|, le code n'en devient pas invalide. L'exécution continuera en exécutant le code dans le case suivant, jusqu'à
rencontrer un \verb|break|, ou la fin du block \verb|switch|.
\vspace{0.3cm}
\par
On dit que l'exécution \textit{déborde} dans le \verb|case| suivant.
{\footnotesize\begin{exampleblock}{Débordement d'un cas}
\begin{verbatim}
switch(a) {
case 1: // si a == 1, les instructions 1 et 2
//instructions 1 // sont exécutées
case 2: // si a == 2, seules les instructions 2
//instructions 2 // sont exécutées
break;
default: // si a n'est pas égal à 1, 2 ou 3, alors
//instructions 3 // les instructions 3 et 4 sont exécutées
case 3: // si a == 3, seules les instructions 4
//instructions 4 // sont exécutées
}\end{verbatim}
\end{exampleblock}}
\end{frame}

18
branchements/20.tex Normal file
View file

@ -0,0 +1,18 @@
\begin{frame}[containsverbatim]
\frametitle{\secname}
\framesubtitle{\subsecname~I}
La boucle \verb|while| permet de faire se répéter les instructions contenues dans son block jusqu'à ce que la condition devienne fausse.
\vspace{0.5cm}
\par
La condition est évaluée à l'entrée dans la boucle (si la condition est fausse à la première évaluation, le code du block est complètement ignoré), puis réévaluée
à chaque fois que toutes les instructions du block ont été exécutées.
\vspace{0.5cm}
\begin{block}{Syntaxe générale d'une boucle while}
\begin{verbatim}
while(condition) {
//instructions
}\end{verbatim}
\end{block}
\end{frame}

14
branchements/21.tex Normal file
View file

@ -0,0 +1,14 @@
\begin{frame}[containsverbatim]
\frametitle{\secname}
\framesubtitle{\subsecname~II}
\begin{exampleblock}{Exemple d'utilisation d'une boucle while}
\begin{verbatim}
char val = 0;
val = keyboardInput();
while(val < 1 || val > 5) {
val = keyboardInput();
}\end{verbatim}
\end{exampleblock}
\end{frame}

16
branchements/22.tex Normal file
View file

@ -0,0 +1,16 @@
\begin{frame}[containsverbatim]
\frametitle{\secname}
\framesubtitle{\subsecname~III}
\begin{exampleblock}{Exemple de boucle while dans laquelle on ne rentre pas}
\begin{verbatim}
void countDown(int val) {
// Si val <= 0, on ne rentre pas dans la boucle
while(val > 0) {
display(val);
val--;
}
}\end{verbatim}
\end{exampleblock}
\end{frame}

18
branchements/23.tex Normal file
View file

@ -0,0 +1,18 @@
\begin{frame}[containsverbatim]
\frametitle{\secname}
\framesubtitle{\subsecname~I}
La boucle \verb|do-while| est identique à la boucle \verb|while| à ceci près que l'évaluation de la condition est effectuée en fin de boucle. De fait, on entre
systématiquement dans la boucle et son block est exécuté au moins une fois.
\par
Tant que la condition reste vraie, le block est répété.
\begin{block}{Syntaxe générale de la boucle do-while}
\begin{verbatim}
do {
//instructions
} while(condition);\end{verbatim}
\end{block}
\par
Une subtilité~: alors que la boucle \verb|while| n'est par terminée par un point-virgule, la boucle \verb|do-while| l'est.
\end{frame}

14
branchements/24.tex Normal file
View file

@ -0,0 +1,14 @@
\begin{frame}[containsverbatim]
\frametitle{\secname}
\framesubtitle{\subsecname~II}
\begin{exampleblock}{Exemple d'utilisation d'une boucle do-while}
\begin{verbatim}
char val;
//saisie au clavier d'un nombre entre 1 et 5
do {
val = keyboardInput();
} while(val < 1 || val > 5);\end{verbatim}
\end{exampleblock}
\end{frame}

16
branchements/25.tex Normal file
View file

@ -0,0 +1,16 @@
\begin{frame}[containsverbatim]
\frametitle{\secname}
\framesubtitle{\subsecname~I}
La boucle \verb|for| est la boucle la plus versatile en C. Elle est composée de 3 parties : \textbf{l'initialisation}, qui est exécuté une seule fois, au début de
la boucle, \textbf{la condition}, qui est évaluée à chaque tour de boucle (y compris à l'entrée dans la boucle, juste après l'initialisation), et une troisième partie,
exécutée à chaque fin de tour de boucle, juste avant que la condition ne soit réévaluée.
\vspace{0.5cm}
\begin{block}{Syntaxe générale d'une boucle for}
\begin{verbatim}
for( initialisation ; condition ; incrémentation) {
//instructions
}\end{verbatim}
\end{block}
\end{frame}

17
branchements/26.tex Normal file
View file

@ -0,0 +1,17 @@
\begin{frame}[containsverbatim]
\frametitle{\secname}
\framesubtitle{\subsecname~II}
\begin{exampleblock}{Exemple d'utilisation simple de la boucle for}
\begin{verbatim}
int i;
for(i = 0 ; i < 5 ; i++) {
display(i);
}\end{verbatim}
\end{exampleblock}
\vspace{0.5cm}
\par
Le code précédent affiche 0, 1, 2, 3, 4. Au cinquième tour de boucle, i est incrémenté et passe à la valeur 5. La condition, évaluée juste après l'incrémentation,
devient fausse, et on sort de la boucle.
\end{frame}

16
branchements/27.tex Normal file
View file

@ -0,0 +1,16 @@
\begin{frame}[containsverbatim]
\frametitle{\secname}
\framesubtitle{\subsecname~III}
La boucle \verb|for| du slide précédent est équivalente à la boucle \verb|while| suivante, mais est plus lisible, car plus expressive (compacte).
\vspace{0.5cm}
\begin{exampleblock}{Boucle while équivalente}
\begin{verbatim}
int i = 0;
while(i < 5) {
display(i);
i++;
}\end{verbatim}
\end{exampleblock}
\end{frame}

16
branchements/28.tex Normal file
View file

@ -0,0 +1,16 @@
\begin{frame}[containsverbatim]
\frametitle{\secname}
\framesubtitle{\subsecname~IV}
Depuis C99, il est possible de déclarer le compteur i directement dans la partie initialisation de la boucle. Ce compteur a alors une durée de vie égale au corps de
la boucle.
\vspace{0.5cm}
\begin{exampleblock}{Déclaration du compteur dans l'initialisation~: C99}
\begin{verbatim}
for(int i = 0 ; i < 5 ; i++) {
display(i);
}
// i n'existe plus\end{verbatim}
\end{exampleblock}
\end{frame}

23
branchements/29.tex Normal file
View file

@ -0,0 +1,23 @@
\begin{frame}[containsverbatim]
\frametitle{\secname}
\framesubtitle{\subsecname~V}
Chaque partie du for peut être vide.