initial
This commit is contained in:
Florian Maury
commit
0b4615ed74
227 changed files with 5555 additions and 0 deletions
84
CoursC.tex
Normal file
84
CoursC.tex
Normal 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
75
SujetTP2011.tex
Normal 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
86
TD1.tex
Normal 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
139
TD2.tex
Normal 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
183
TD3.tex
Normal 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
88
TP1-2011.tex
Normal 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
286
TP2.tex
Normal 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
21
branchements/01.tex
Normal 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
17
branchements/02.tex
Normal 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
24
branchements/03.tex
Normal 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
17
branchements/04.tex
Normal 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
23
branchements/05.tex
Normal 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
21
branchements/06.tex
Normal 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
19
branchements/07.tex
Normal 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
24
branchements/08.tex
Normal 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
22
branchements/09.tex
Normal 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
21
branchements/10.tex
Normal 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
21
branchements/11.tex
Normal 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
22
branchements/12.tex
Normal 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
24
branchements/13.tex
Normal 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
24
branchements/14.tex
Normal 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
26
branchements/15.tex
Normal 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
20
branchements/16.tex
Normal 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
10
branchements/17.tex
Normal 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
23
branchements/18.tex
Normal 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
25
branchements/19.tex
Normal 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
18
branchements/20.tex
Normal 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
14
branchements/21.tex
Normal 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
16
branchements/22.tex
Normal 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
18
branchements/23.tex
Normal 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
14
branchements/24.tex
Normal 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
16
branchements/25.tex
Normal 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
17
branchements/26.tex
Normal 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
16
branchements/27.tex
Normal 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
16
branchements/28.tex
Normal 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
23
branchements/29.tex
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~V}
|
||||
|
||||
Chaque partie du for peut être vide.
|
||||
\par
|
||||
Si la partie initialisation est vide, il n'y a pas d'initialisation avant l'exécution de la boucle.
|
||||
\par
|
||||
Si la partie incrémentation est vide, il n'y a pas d'incrémentation avant l'évaluation de la condition, à chaque tour de boucle.
|
||||
\par
|
||||
Si la partie condition est vide, la condition est évaluée à vraie. On obtient une boucle infinie.
|
||||
|
||||
{\small\begin{exampleblock}{Boucle infinie}
|
||||
\begin{verbatim}
|
||||
for(;;) {
|
||||
// instructions exécutées à l'infini
|
||||
}\end{verbatim}
|
||||
\end{exampleblock}}
|
||||
\begin{alertblock}{Boucles infinies}
|
||||
Les boucles infinies sont à éviter absolument. Elles sont employées dans certains cas d'optimisation algorithmique avancée.
|
||||
\end{alertblock}
|
||||
\end{frame}
|
||||
|
||||
19
branchements/30.tex
Normal file
19
branchements/30.tex
Normal file
|
|
@ -0,0 +1,19 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~VI}
|
||||
|
||||
Il est possible d'effectuer plusieurs opérations d'initialisation et d'incrémentation en les séparant par des virgules. Ce genre de pratique est notamment vu lors
|
||||
de l'entretien simultané de plusieurs compteurs.
|
||||
\vspace{0.5cm}
|
||||
\begin{exampleblock}{Deux compteurs dans une même boucle for}
|
||||
\begin{verbatim}
|
||||
int i, j;
|
||||
for(i = 0, j = 5 ; i < 5 ; i++, j--) {
|
||||
display(i, j);
|
||||
}\end{verbatim}
|
||||
\end{exampleblock}
|
||||
\vspace{0.5cm}
|
||||
\par
|
||||
Cette boucle afficherait 0, 1, 2, 3, 4 pour les valeurs de \verb|i|, et 5, 4, 3, 2, 1 pour les valeurs de \verb|j|.
|
||||
\end{frame}
|
||||
|
||||
23
branchements/31.tex
Normal file
23
branchements/31.tex
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~VII}
|
||||
|
||||
La boucle \verb|for| ne se limite cependant pas à la gestion de compteurs. Il est parfaitement possible de détourner son utilisation avec des fonctions \ldots
|
||||
{\small\begin{exampleblock}{Boucle for utilisant des fonctions}
|
||||
\begin{verbatim}
|
||||
for( ListElement t = getFirstElement(myList) ;
|
||||
hasNext(t) ;
|
||||
t = nextElement(t)) {
|
||||
// traitement de la liste
|
||||
}\end{verbatim}
|
||||
\end{exampleblock}}
|
||||
Ou des conditions complexes \ldots
|
||||
{\small\begin{exampleblock}{Boucle for utilisant des fonctions}
|
||||
\begin{verbatim}
|
||||
bool mustStop = false;
|
||||
for(int i = 0 ; i < 100 && !mustStop ; i++) {
|
||||
// instructions qui peuvent mettre mustStop à vrai
|
||||
}\end{verbatim}
|
||||
\end{exampleblock}}
|
||||
\end{frame}
|
||||
|
||||
12
branchements/32.tex
Normal file
12
branchements/32.tex
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: break}
|
||||
|
||||
L'instruction \verb|break|, lorsqu'elle est rencontrée dans une boucle (while, do-while ou for) cause la sortie immédiate de la boucle, quelque soit l'évaluation
|
||||
de la condition, et sans exécuter les instructions restantes du block de la boucle.
|
||||
\vspace{0.5cm}
|
||||
\par
|
||||
Un cas d'utilisation possible est dans l'exemple précédent où nous avons utilisé un booléen \verb|mustStop| pour dire à la fonction de sortir, avant la fin de
|
||||
son compteur. Nous aurions pu utiliser une instruction \verb|break| pour sortir immédiatement de la boucle.
|
||||
\end{frame}
|
||||
|
||||
12
branchements/33.tex
Normal file
12
branchements/33.tex
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: continue}
|
||||
|
||||
L'instruction \verb|continue|, lorsqu'elle est rencontrée dans une boucle (while, do-while ou for) cause le début immédiat d'une nouvelle itération de la boucle. Les
|
||||
instructions restantes de la boucle sont ignorées. La condition est immédiatement évaluée, et dans le cas de la boucle for, le code de la partie incrémentation est
|
||||
exécuté avant l'évaluation de la condition.
|
||||
\vspace{0.5cm}
|
||||
\par
|
||||
Cette instruction est principalement utilisée dans le cadre de l'optimisation avancée des boucles, ou pour améliorer la lisibilité (encore que, cela reste discutable).
|
||||
\end{frame}
|
||||
|
||||
17
branchements/34.tex
Normal file
17
branchements/34.tex
Normal file
|
|
@ -0,0 +1,17 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname}
|
||||
|
||||
Ce sujet n'est abordé que parce qu'il est malheureusement couramment rencontré \ldots
|
||||
\vspace{0.5cm}
|
||||
\par
|
||||
Lors de l'utilisation des mot-clés if, else, while, et for, si les blocks de ces derniers ne contiennent qu'une seule instruction, il est possible d'omettre les
|
||||
accolades.
|
||||
\vspace{0.5cm}
|
||||
\par
|
||||
Cette notation est \textbf{vivement déconseillée}, car elle favorise les bugs.
|
||||
\par
|
||||
Aucun exemple ne sera fourni.
|
||||
\par
|
||||
Il est possible de l'utiliser correctement dans certains cas que nous n'aborderons pas dans ce cours.
|
||||
\end{frame}
|
||||
83
branchements/branchements.tex
Normal file
83
branchements/branchements.tex
Normal file
|
|
@ -0,0 +1,83 @@
|
|||
\subsection*{Branchements conditionnels~: Famille if}
|
||||
|
||||
\input{branchements/01}
|
||||
|
||||
\input{branchements/02}
|
||||
|
||||
\input{branchements/03}
|
||||
|
||||
\input{branchements/04}
|
||||
|
||||
\input{branchements/05}
|
||||
|
||||
\input{branchements/06}
|
||||
|
||||
\input{branchements/07}
|
||||
|
||||
\input{branchements/08}
|
||||
|
||||
\input{branchements/09}
|
||||
|
||||
\input{branchements/10}
|
||||
|
||||
\input{branchements/11}
|
||||
|
||||
\input{branchements/12}
|
||||
|
||||
\subsection*{Branchements conditionnels~: Switch}
|
||||
|
||||
\input{branchements/13}
|
||||
|
||||
\input{branchements/14}
|
||||
|
||||
\input{branchements/15}
|
||||
|
||||
\input{branchements/16}
|
||||
|
||||
\input{branchements/17}
|
||||
|
||||
\input{branchements/18}
|
||||
|
||||
\input{branchements/19}
|
||||
|
||||
%XXX: préciser quelque part que peu importe l'ordre des case, sauf en cas de débordement
|
||||
|
||||
\subsection*{Branchements conditionnels~: Boucle While}
|
||||
|
||||
\input{branchements/20}
|
||||
|
||||
\input{branchements/21}
|
||||
|
||||
\input{branchements/22}
|
||||
|
||||
\subsection*{Branchements conditionnels~: Boucle Do-While}
|
||||
|
||||
\input{branchements/23}
|
||||
|
||||
\input{branchements/24}
|
||||
|
||||
\subsection*{Branchements conditionnels~: Boucle For}
|
||||
|
||||
\input{branchements/25}
|
||||
|
||||
\input{branchements/26}
|
||||
|
||||
\input{branchements/27}
|
||||
|
||||
\input{branchements/28}
|
||||
|
||||
\input{branchements/29}
|
||||
|
||||
\input{branchements/30}
|
||||
|
||||
\input{branchements/31}
|
||||
|
||||
\subsection*{Branchements conditionnels~: Boucles~: Les instructions de contrôle}
|
||||
|
||||
\input{branchements/32}
|
||||
|
||||
\input{branchements/33}
|
||||
|
||||
\subsection*{Branchements conditionnels~: Raccourcis d'écriture~: une seule instruction}
|
||||
|
||||
\input{branchements/34}
|
||||
7
generalites/01.tex
Normal file
7
generalites/01.tex
Normal file
|
|
@ -0,0 +1,7 @@
|
|||
\begin{frame}
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname}
|
||||
Un langage de programmation est une méthode de communication pour transposer la volonté d'un développeur
|
||||
en une séquence de commandes, souvent stockée dans un fichier appelé "source", "code source" ou "fichier source"
|
||||
à destination d'une ou plusieurs machines afin qu'elle(s) effectue(nt) une tâche.
|
||||
\end{frame}
|
||||
14
generalites/02.tex
Normal file
14
generalites/02.tex
Normal file
|
|
@ -0,0 +1,14 @@
|
|||
\begin{frame}
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~I}
|
||||
|
||||
Une machine ne comprend qu'un seul langage~: le langage machine, qui est différent d'une architecture à l'autre.
|
||||
\vspace{1cm}
|
||||
\par
|
||||
Ce langage machine est exprimé en binaire, un format très pratique pour elle, mais quasiment illisible pour nous.
|
||||
\vspace{1cm}
|
||||
\par
|
||||
Ce langage machine est donc traduit sous la forme de mnémoniques, plus faciles à manipuler.
|
||||
\par
|
||||
L'ensemble des mnémoniques d'une machine forment son langage \textbf{assembleur}.
|
||||
\end{frame}
|
||||
19
generalites/03.tex
Normal file
19
generalites/03.tex
Normal file
|
|
@ -0,0 +1,19 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~II}
|
||||
\begin{exampleblock}{Hello world en assembleur}
|
||||
\begin{verbatim}
|
||||
.global _start
|
||||
HELLO: .ascii "Hello, World\n"
|
||||
_start:
|
||||
mov $4, %eax
|
||||
mov $1, %ebx
|
||||
mov $HELLO %ecx
|
||||
mov $13, %edx
|
||||
int $0x80
|
||||
mov $1, %eax
|
||||
mov $0, %ebx
|
||||
int $0x80
|
||||
\end{verbatim}
|
||||
\end{exampleblock}
|
||||
\end{frame}
|
||||
16
generalites/04.tex
Normal file
16
generalites/04.tex
Normal file
|
|
@ -0,0 +1,16 @@
|
|||
\begin{frame}
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname}
|
||||
Avantage de l'assembleur~:
|
||||
\begin{itemize}
|
||||
\item Contrôle total (contrôle fin de la machine et accès à tout le jeu d'instructions)
|
||||
\item Disponible sur toutes les plateformes (puisque ``natif'')
|
||||
\end{itemize}
|
||||
Défauts de l'assembleur~:
|
||||
\begin{itemize}
|
||||
\item Trop précis~: un programme écrit sur une architecture risque d'utiliser des instructions non disponibles sur une autre, rendant le programme incompatible
|
||||
\item Fastidieux~: l'expressivité du langage est faible (beaucoup de lignes de code pour faire des choses simples)
|
||||
\item Augmentation du risque de bug à cause de l'augmentation du nombre de lignes de code et du manque de lisibilité
|
||||
\end{itemize}
|
||||
\end{frame}
|
||||
|
||||
17
generalites/05.tex
Normal file
17
generalites/05.tex
Normal file
|
|
@ -0,0 +1,17 @@
|
|||
\begin{frame}
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname}
|
||||
\begin{block}{L'assembleur~: inutile ?!}
|
||||
L'assembleur est utile notamment dans les cas suivants~:
|
||||
\begin{itemize}
|
||||
\item Travail proche de la machine (drivers, kernels\ldots)
|
||||
\item Optimisation avancée
|
||||
\item Reverse engineering \& debugging
|
||||
\item Les shellcodes, les virus, les programmes se réécrivant\ldots
|
||||
\item Dans les systèmes embarqués (ARM, consoles de jeu\ldots)
|
||||
\item Quand il n'existe pas d'autres langages sur une architecture
|
||||
\item Les demoparty \href{http://www.assembly.org}{http://www.assembly.org}
|
||||
\end{itemize}
|
||||
\end{block}
|
||||
\end{frame}
|
||||
|
||||
18
generalites/06.tex
Normal file
18
generalites/06.tex
Normal file
|
|
@ -0,0 +1,18 @@
|
|||
\begin{frame}
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname}
|
||||
Devant la difficulté de coder de grosses applications en assembleur, \textbf{les langages de haut niveau} ont été créés, selon différents paradigmes.
|
||||
\begin{itemize}
|
||||
\item Procéduraux : C, Pascal, PHP4\ldots
|
||||
\item Fonctionnels : Ocaml, Lisp, Erlang\ldots
|
||||
\item Orientés objets : C++, Java, PHP5+, Python, Ocaml\ldots
|
||||
\item Déclaratifs : SGML, XML (xHTML, DocBook, SOAP\ldots)\ldots
|
||||
\item Orientés prototypes : Javascript, Actionscript\ldots
|
||||
\end{itemize}
|
||||
\par
|
||||
Le C est considéré par certains comme un langage de bas niveau.
|
||||
\par
|
||||
Les méchanismes de sécurité et d'abstraction y étant minimaux (par défaut), le C est principalement utilisé lorsque \textbf{la performance est un enjeu majeur} ou
|
||||
lorsqu'un \textbf{contrôle fin de la machine} est nécessaire.
|
||||
\end{frame}
|
||||
|
||||
16
generalites/07.tex
Normal file
16
generalites/07.tex
Normal file
|
|
@ -0,0 +1,16 @@
|
|||
\begin{frame}
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: La compilation I}
|
||||
La compilation est l'étape qui permet de \emph{convertir un code exprimé dans un langage en du code exprimé dans un autre}.
|
||||
\vspace{1cm}
|
||||
\par
|
||||
Le C, par exemple, est ``compilé'' en assembleur, lui même ``compilé'' en langage machine.
|
||||
\vspace{1cm}
|
||||
\par
|
||||
Les compilateurs C les plus répandus sont~:
|
||||
\begin{itemize}
|
||||
\item \textbf{Visual Studio C++} pour Windows
|
||||
\item \textbf{GCC} pour les *nix
|
||||
\end{itemize}
|
||||
\end{frame}
|
||||
|
||||
15
generalites/08.tex
Normal file
15
generalites/08.tex
Normal file
|
|
@ -0,0 +1,15 @@
|
|||
\begin{frame}
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: La compilation II}
|
||||
La compilation du C inclut notamment les étapes suivantes~:
|
||||
\begin{itemize}
|
||||
\item une interprétation des \emph{directives de compilation}
|
||||
\item La \emph{vérification syntaxique} du programme
|
||||
\item Des \emph{optimisations} diverses (alignements de mémoire, réorganisation du code indépendant, précalculs\ldots)
|
||||
\item La \emph{transcription} du programme en code machine
|
||||
\item \emph{L'assemblage} des éléments du programme et \emph{reliage (“linking”)} entre eux (ainsi qu'à des bibliothèques externes)
|
||||
\end{itemize}
|
||||
\vspace{0.5cm}
|
||||
A l'issu de la compilation, on dispose d'exécutables (fichiers PE sous Windows (les fameux .exe) ou fichiers ELF sous GNU/Linux).
|
||||
\end{frame}
|
||||
|
||||
17
generalites/09.tex
Normal file
17
generalites/09.tex
Normal file
|
|
@ -0,0 +1,17 @@
|
|||
\begin{frame}
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: L'interprétation}
|
||||
\par
|
||||
Un interpréteur lit le code source d'un programme en langage interprété et l'analyse.
|
||||
\par
|
||||
Les instructions du langage interprété déclenchent alors l'exécution de portions de code de l'interpréteur.
|
||||
\par
|
||||
Le processeur exécute donc du code de l'interpréteur, sur les directives du langage interprété.
|
||||
\par
|
||||
L'étape de lecture et d'analyse du code interprété est effectué à \textbf{chaque} exécution, causant un surcoût en temps de calcul,
|
||||
et amoindrissant fortement les performances de ces applications.
|
||||
\par
|
||||
La contre-partie est que le code interprété est ``managé'' par l'interpréteur, permettant (du moins, plus facilement) des
|
||||
fonctionnalités telles que le \emph{ramasse-miette (Garbage Collecting)} et souvent une plus grande expressivité.
|
||||
\end{frame}
|
||||
|
||||
16
generalites/10.tex
Normal file
16
generalites/10.tex
Normal file
|
|
@ -0,0 +1,16 @@
|
|||
\begin{frame}
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~I}
|
||||
\par
|
||||
Le C++ est une surcouche au C, ajoutant principalement l'orientation objet,
|
||||
les templates, et les flux. Réputé plus lourd, plus lent à compiler, et moins lisible
|
||||
que le C, il reste un langage de choix pour le développement de gros projets.
|
||||
\vspace{0.5cm}
|
||||
\par
|
||||
L'Objective C est une surcouche au C, développé par NeXTStep puis Apple,
|
||||
et principalement utilisé pour le développement d'applications sous Mac OS
|
||||
et iOS. La librairie GnuStep permet le développement sous l'OS GNU.
|
||||
C'est un langage au typage plus faible que le C, et avec quelques améliorations
|
||||
comme les messages.
|
||||
\end{frame}
|
||||
|
||||
17
generalites/11.tex
Normal file
17
generalites/11.tex
Normal file
|
|
@ -0,0 +1,17 @@
|
|||
\begin{frame}
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~II}
|
||||
|
||||
\par
|
||||
Les compilateurs C++ (globalement) et Objective C peuvent compiler du C standard.
|
||||
\vspace{0.5cm}
|
||||
\par\hrulefill\par
|
||||
\vspace{0.5cm}
|
||||
\par
|
||||
C\# n'est pas à proprement parler un descendant de C, si ce n'est de manière
|
||||
grossière par sa syntaxe à certains niveaux.
|
||||
\par
|
||||
C\# est un des langages compilés en code intermédiaire puis interprété par le CLR de Microsoft/Novell dans le cadre du
|
||||
framework .NET/Mono.
|
||||
\end{frame}
|
||||
|
||||
18
generalites/12.tex
Normal file
18
generalites/12.tex
Normal file
|
|
@ -0,0 +1,18 @@
|
|||
\begin{frame}
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname}
|
||||
{\small Le langage C est~:}
|
||||
\begin{itemize}
|
||||
\item {\small compilé}
|
||||
\item {\small fortement typé}
|
||||
\item {\small proche de la machine (et donc parfois pas nécessairement portable)}
|
||||
\item {\small performant}
|
||||
\item {\small permettant l'intégration d'assembleur pour plus de performances}
|
||||
\item {\small ayant un compilateur pour presque toutes les plateformes}
|
||||
\item {\small versatile (applications de bureau, Web, réseaux\ldots)}
|
||||
\item {\small très utilisé (et donc très bien documenté et éprouvé)}
|
||||
\item {\small vieillisant (pas de OOP, gestion manuelle de la mémoire\ldots)}
|
||||
\item {\small difficile (gestion manuelle de la mémoire, pas de sécurité intégrée\ldots)}
|
||||
\end{itemize}
|
||||
\end{frame}
|
||||
|
||||
35
generalites/generalites.tex
Normal file
35
generalites/generalites.tex
Normal file
|
|
@ -0,0 +1,35 @@
|
|||
\subsection*{Qu'est ce qu'un langage de programmation ?}
|
||||
|
||||
\input{generalites/01}
|
||||
|
||||
\subsection*{L'assembleur par rapport au C}
|
||||
|
||||
\input{generalites/02}
|
||||
|
||||
\input{generalites/03}
|
||||
|
||||
\input{generalites/04}
|
||||
|
||||
\input{generalites/05}
|
||||
|
||||
\subsection*{Les HLL~: High Level Languages (Langages de haut niveau)}
|
||||
|
||||
\input{generalites/06}
|
||||
|
||||
\subsection*{La compilation VS l'interprétation}
|
||||
|
||||
\input{generalites/07}
|
||||
|
||||
\input{generalites/08}
|
||||
|
||||
\input{generalites/09}
|
||||
|
||||
\subsection*{La famille du langage C}
|
||||
|
||||
\input{generalites/10}
|
||||
|
||||
\input{generalites/11}
|
||||
|
||||
\subsection*{Caractéristiques du C}
|
||||
|
||||
\input{generalites/12}
|
||||
23
operateurs/01.tex
Normal file
23
operateurs/01.tex
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: L'opérateur ++}
|
||||
|
||||
Cet opérateur peut \textit{préfixer} ou \textit{suffixer} son opérande.
|
||||
\vspace{0.3cm}
|
||||
\par
|
||||
Son effet est l'\textbf{incrémentation}~: il augmente la valeur de son opérande de 1.
|
||||
\vspace{0.3cm}
|
||||
\par
|
||||
Si l'opérateur préfixe l'opérande, l'opérande est incrémenté, puis sa valeur est retournée, afin que l'expression qui les contient soit évaluée à son tour.
|
||||
\vspace{0.3cm}
|
||||
\par
|
||||
Si l'opérateur suffixe l'opérande, la valeur est retournée, puis l'opérande voit sa valeur incrémentée.
|
||||
\vspace{0.3cm}
|
||||
\begin{exampleblock}{Exemples d'utilisation de ++}
|
||||
\begin{verbatim}
|
||||
int a = 3;
|
||||
int b = a++ + 4; // b reçoit 7, et a vaut maintenant 4
|
||||
int c = ++a + 4; // a vaut 5, et c vaut 9\end{verbatim}
|
||||
\end{exampleblock}
|
||||
\end{frame}
|
||||
|
||||
23
operateurs/02.tex
Normal file
23
operateurs/02.tex
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: L'opérateur -\relax-}
|
||||
|
||||
Cet opérateur peut \textit{préfixer} ou \textit{suffixer} son opérande.
|
||||
\vspace{0.3cm}
|
||||
\par
|
||||
Son effet est la \textbf{décrémentation}~: il diminue la valeur de son opérande de 1.
|
||||
\vspace{0.3cm}
|
||||
\par
|
||||
Si l'opérateur préfixe l'opérande, l'opérande est décrémenté, puis sa valeur est retournée, afin que l'expression qui les contient soit évaluée à son tour.
|
||||
\vspace{0.3cm}
|
||||
\par
|
||||
Si l'opérateur suffixe l'opérande, la valeur est retournée, puis l'opérande voit sa valeur décrémentée.
|
||||
\vspace{0.3cm}
|
||||
\begin{exampleblock}{Exemples d'utilisation de -\relax-}
|
||||
\begin{verbatim}
|
||||
int a = 3;
|
||||
int b = a-- + 4; // b reçoit 7, et a vaut maintenant 2
|
||||
int c = --a + 4; // a vaut 1, et c vaut 5\end{verbatim}
|
||||
\end{exampleblock}
|
||||
\end{frame}
|
||||
|
||||
17
operateurs/03.tex
Normal file
17
operateurs/03.tex
Normal file
|
|
@ -0,0 +1,17 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: L'opérateur -}
|
||||
|
||||
Cet opérateur préfixe son opérande.
|
||||
\vspace{0.3cm}
|
||||
\par
|
||||
La valeur retournée par l'opérande est évaluée et multipliée par $-1$. La valeur de l'opérande n'est pas modifiée.
|
||||
\begin{exampleblock}{Exemples d'utilisation de l'opérateur -}
|
||||
\begin{verbatim}
|
||||
int a = 3;
|
||||
int b = -a; // a vaut toujours 3, et b -3
|
||||
int c = -(a + 4); // a vaut 3, et c faut -7
|
||||
\end{verbatim}
|
||||
\end{exampleblock}
|
||||
\end{frame}
|
||||
|
||||
23
operateurs/04.tex
Normal file
23
operateurs/04.tex
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: L'opérateur $\sim$ (non binaire)}
|
||||
|
||||
Cet opérateur préfixe son opérande.
|
||||
\vspace{0.3cm}
|
||||
\par
|
||||
La valeur retournée par l'opérande est transformée en son complément à 1. Autrement dit, tous ses bits à 0 passent à 1, et tous ses bits à 1 passent à 0.
|
||||
{\small\begin{alertblock}{Attention à la taille de l'opérande !}
|
||||
La \textbf{taille en mémoire} de l'opérande est \textbf{capitale} pour cet opérateur.
|
||||
\par
|
||||
Par exemple, un \verb|char| x (de taille 1 octet, soit 8 bits) de valeur 1 est représenté en mémoire par \texttt{00000001}.
|
||||
\par
|
||||
$\sim$x vaut alors \texttt{11111110}.
|
||||
\par
|
||||
Si x était un \verb|int|, alors sa représentation en mémoire serait 31 bits à 0, et 1 bit à 1. $\sim$x serait alors 31 bits à 1, et 1 bit à 0, ce qui
|
||||
représente la même valeur d'un point de vue ``base 10'', mais est fondamentalement différent d'un point de vue arithmétique binaire.
|
||||
\end{alertblock}
|
||||
\begin{exampleblock}{Exemple d'utilisation du non binaire}
|
||||
\verb|int a = |$\sim$\verb|1; // a vaut 31 bits à 1, et un bit à 0|
|
||||
\end{exampleblock}}
|
||||
\end{frame}
|
||||
|
||||
24
operateurs/05.tex
Normal file
24
operateurs/05.tex
Normal file
|
|
@ -0,0 +1,24 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: L'opérateur ! (non logique)~I}
|
||||
|
||||
Cet opérateur a pour effet d'inverser un opérande logique, c'est à dire qu'il transforme une condition vraie en une condition fausse et inversement.
|
||||
\vspace{0.3cm}
|
||||
\par
|
||||
En C, le type booléen n'existe pas, et même s'il est émulé avec la bibliothèque $<$stdbool.h$>$ en C99, la réalité est que :
|
||||
\begin{itemize}
|
||||
\item 0 vaut pour faux
|
||||
\item 1 et toutes les autres valeurs non nulles valent pour vrai
|
||||
\end{itemize}
|
||||
|
||||
{\small\begin{exampleblock}{Exemple d'inversion logique sur un retour de fonction}
|
||||
\begin{verbatim}
|
||||
#include <stdbool.h>
|
||||
bool estEgal(int a, int b);
|
||||
int result = ! estEgal(1, 2); // result vaut 1\end{verbatim}
|
||||
\end{exampleblock}}
|
||||
\par
|
||||
Bien que l'utilisation précédente soit courante, on rencontre encore plus souvent cet opérateur lorsqu'on souhaite inverser une condition exprimée à l'aide de certains
|
||||
opérateurs binaires tels que $<$, $>$, \verb|==| et assimilés que nous expliquerons avant longtemps.
|
||||
\end{frame}
|
||||
|
||||
11
operateurs/06.tex
Normal file
11
operateurs/06.tex
Normal file
|
|
@ -0,0 +1,11 @@
|
|||
\begin{frame}
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: Les opérateurs * et \&}
|
||||
|
||||
L'opérateur * est l'opérateur de déréférencement.
|
||||
\vspace{0.5cm}
|
||||
\par
|
||||
L'opérateur \& est l'opérateur permettant le renvoi de l'adresse d'une variable en mémoire. Ces deux opérateurs seront
|
||||
étudiés lors du chapitre sur les pointeurs.
|
||||
\end{frame}
|
||||
|
||||
14
operateurs/07.tex
Normal file
14
operateurs/07.tex
Normal file
|
|
@ -0,0 +1,14 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: L'opérateur +}
|
||||
|
||||
Cet opérateur effectue la somme de son opérande gauche avec son opérande droit avant de retourner son résultat. Il ne modifie pas la valeur
|
||||
des opérandes.
|
||||
\vspace{0.5cm}
|
||||
\begin{exampleblock}{Exemple d'addition}
|
||||
\begin{verbatim}
|
||||
int a = 3;
|
||||
int b = 4 + a + 2; // b vaut 9, a vaut toujours 3\end{verbatim}
|
||||
\end{exampleblock}
|
||||
\end{frame}
|
||||
|
||||
14
operateurs/08.tex
Normal file
14
operateurs/08.tex
Normal file
|
|
@ -0,0 +1,14 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: L'opérateur -}
|
||||
|
||||
Cet opérateur effectue la soustraction de son opérande droit à son opérande gauche avant de retourner son résultat. Il ne modifie pas la valeur
|
||||
des opérandes.
|
||||
\vspace{0.5cm}
|
||||
\begin{exampleblock}{Exemple de soustraction}
|
||||
\begin{verbatim}
|
||||
int a = 3;
|
||||
int b = 4 - a; // b vaut 1, a vaut toujours 3\end{verbatim}
|
||||
\end{exampleblock}
|
||||
\end{frame}
|
||||
|
||||
15
operateurs/09.tex
Normal file
15
operateurs/09.tex
Normal file
|
|
@ -0,0 +1,15 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: L'opérateur *}
|
||||
|
||||
Cet opérateur effectue la multiplication de son opérande gauche avec son opérande droit avant de retourner son résultat. Il ne modifie pas la valeur
|
||||
des opérandes.
|
||||
\vspace{0.5cm}
|
||||
\begin{exampleblock}{Exemple de multiplication}
|
||||
\begin{verbatim}
|
||||
int a = 3;
|
||||
int b = 4 * a; // b vaut 12, a vaut toujours 3\end{verbatim}
|
||||
\end{exampleblock}
|
||||
|
||||
\end{frame}
|
||||
|
||||
20
operateurs/10.tex
Normal file
20
operateurs/10.tex
Normal file
|
|
@ -0,0 +1,20 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: Un point sur les parenthèses}
|
||||
|
||||
En C, lorsque plusieurs opérateurs sont chainés dans une même expression, il existe des règles de priorité de résolution, tout comme en mathématiques.
|
||||
\vspace{0.5cm}
|
||||
\par
|
||||
Nous verrons plus tard l'ordre de priorité des opérateurs, qui est parfois contre-intuitif. Les parenthèses peuvent être utilisées pour retirer
|
||||
des ambiguïtés (simplifier une opération en la rendant plus lisible) ou pour forcer un changement de priorité\ldots comme en mathématiques.
|
||||
\vspace{0.5cm}
|
||||
\begin{exampleblock}{Exemple d'utilisation des parenthèses}
|
||||
\par
|
||||
La multiplication est prioritaire sur l'addition, en C. L'opération $5 * 3 + 2$ vaut 17 en mathématiques, comme en C.
|
||||
\par
|
||||
On peut modifier l'ordre à l'aide de parenthèse de manière classique~:
|
||||
\begin{verbatim}
|
||||
int a = 5 * (3 + 2); // a vaut 25 \end{verbatim}
|
||||
\end{exampleblock}
|
||||
\end{frame}
|
||||
|
||||
22
operateurs/11.tex
Normal file
22
operateurs/11.tex
Normal file
|
|
@ -0,0 +1,22 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: L'opérateur = (affectation)~I}
|
||||
|
||||
Nous l'avons déjà abordé précédemment, mais cet opérateur est plus complexe qu'à premier abord.
|
||||
\vspace{0.3cm}
|
||||
\par
|
||||
Cet opérateur effectue l'affectation de la valeur retournée par son opérande gauche à son opérande droit (parfois appelé \textit{LVALUE}), \textbf{puis retourne la valeur affectée}.
|
||||
\vspace{0.3cm}
|
||||
\par
|
||||
Cela signifie que l'action de cet opérateur ne se résume pas à l'affectation de valeur, et génère elle-même une valeur, égale à la valeur affectée.
|
||||
\vspace{0.3cm}
|
||||
\par
|
||||
Autrement dit, la ligne de code suivante génère la valeur 3~:
|
||||
\begin{exampleblock}{L'affectation retourne une valeur}
|
||||
\begin{verbatim}
|
||||
char a;
|
||||
a = 3; // cette expression retourne la valeur 3
|
||||
// en plus d'affecter 3 à la variable a\end{verbatim}
|
||||
\end{exampleblock}
|
||||
\end{frame}
|
||||
|
||||
21
operateurs/12-1.tex
Normal file
21
operateurs/12-1.tex
Normal file
|
|
@ -0,0 +1,21 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: L'opérateur = (affectation)~III}
|
||||
|
||||
Les variables de type structuré sont considérées comme des éléments atomiques pour l'opérateur d'affectation.
|
||||
\vspace{0.3cm}
|
||||
\par
|
||||
S'il est possible d'affecter individuellement chaque membre d'une variable structurée, il est possible de recopier toutes les valeurs
|
||||
des membres d'une structure dans les membres d'une autre variable structurée par simple affectation.
|
||||
\begin{exampleblock}{Affectation d'une structure à une autre}
|
||||
\begin{verbatim}
|
||||
struct Exemple { int a; int b; } var1, var2;
|
||||
var1.a = 5; var1.b = 3;
|
||||
var2 = var1; // var2.a vaut 5, et var2.b vaut 3\end{verbatim}
|
||||
\end{exampleblock}
|
||||
{\small\begin{alertblock}{Attention aux pointeurs}
|
||||
Attention, l'affectation ne duplique pas les pointeurs ! Il faudra les dédupliquer à la main. Nous reviendrons dessus lorsque nous verrons
|
||||
les pointeurs.
|
||||
\end{alertblock}}
|
||||
\end{frame}
|
||||
|
||||
24
operateurs/12.tex
Normal file
24
operateurs/12.tex
Normal file
|
|
@ -0,0 +1,24 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: L'opérateur = (affectation)~II}
|
||||
|
||||
Du fait que l'affectation retourne une valeur, il est possible de chainer les affectations ou d'effectuer des affectations au milieu d'autres
|
||||
opérations.
|
||||
\par
|
||||
\vspace{0.3cm}
|
||||
{\small\begin{exampleblock}{Chainage d'affectations}
|
||||
\begin{verbatim}
|
||||
int a, b;
|
||||
a = b = 3;\end{verbatim}
|
||||
\verb|a| reçoit le résultat de son opérande droit \verb|b = 3|, soit la valeur 3.
|
||||
\par
|
||||
\verb|b| reçoit 3.
|
||||
\end{exampleblock}
|
||||
\begin{exampleblock}{Affectation au milieu d'une opération}
|
||||
\begin{verbatim}
|
||||
int a, b;
|
||||
b = (a = 4) + 2; //a vaut 4, et b vaut 6\end{verbatim}
|
||||
\verb|a| reçoit 4, et l'affectation renvoie 4 qui est sommé à 2, formant 6 qui est affecté à \verb|b|.
|
||||
\end{exampleblock}}
|
||||
\end{frame}
|
||||
|
||||
16
operateurs/13.tex
Normal file
16
operateurs/13.tex
Normal file
|
|
@ -0,0 +1,16 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: L'opérateur , (virgule)~I}
|
||||
|
||||
Cet opérateur est assez peu utilisé, en dehors des première et dernière clauses de la boucle \verb|for| (que nous verrons plus tard), en tant
|
||||
que séparateur d'instructions.
|
||||
\vspace{0.3cm}
|
||||
\par
|
||||
On voit le symbole virgule plus fréquemment dans les déclarations, et les initialisations en tant que séparateur, mais il s'agit juste d'une
|
||||
réutilisation du symbole.
|
||||
\vspace{0.3cm}
|
||||
\par
|
||||
Cet opérateur ne modifie pas ses opérandes et n'a pour seul effet que de renvoyer la valeur de son opérande de droite. En général, l'opérande
|
||||
de gauche est un appel de fonction, une altération de variable, un affichage, ou tout autre effet de bord.
|
||||
\end{frame}
|
||||
|
||||
20
operateurs/14.tex
Normal file
20
operateurs/14.tex
Normal file
|
|
@ -0,0 +1,20 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: L'opérateur , (virgule)~II}
|
||||
|
||||
\begin{exampleblock}{Exemple d'utilisation de l'opérateur ,}
|
||||
\begin{verbatim}
|
||||
void ajouterTVA(float *value);
|
||||
float prixBase = 15.63, prixFinal, marge = 3;
|
||||
|
||||
// prixBase est modifié par la fonction,
|
||||
// puis sa valeur + marge est affectée à prixFinal.
|
||||
prixFinal = ajouterTVA(&prixBase), prixBase + marge;
|
||||
|
||||
//Equivalent :
|
||||
|
||||
ajouterTVA(&prixBase);
|
||||
prixFinal = prixBase + marge;\end{verbatim}
|
||||
\end{exampleblock}
|
||||
\end{frame}
|
||||
|
||||
23
operateurs/15.tex
Normal file
23
operateurs/15.tex
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: L'opérateur /}
|
||||
|
||||
Cet opérateur effectue la division de son opérande gauche par son opérande droit.
|
||||
\vspace{0.3cm}
|
||||
\par
|
||||
La valeur retournée est de type \verb|int| (éventuellement
|
||||
arrondie à l'inférieur) si les deux opérandes sont des entiers, ou de type \verb|double| si au moins l'un des opérandes est de type flottant.
|
||||
\vspace{0.3cm}
|
||||
{\small\begin{exampleblock}{Exemples d'utilisations de l'opérateur /}
|
||||
\begin{verbatim}
|
||||
int a = 15, b = 7, result1;
|
||||
float c = 2.5, result2;
|
||||
result1 = 4 / 2; //result1 vaut 2
|
||||
result1 = a / b; //result1 vaut 2
|
||||
result1 = a / 8; //result1 vaut 1
|
||||
result2 = ((float) a) / 2; //result2 vaut 7,5
|
||||
result2 = a / 2.0; //result2 vaut 7,5
|
||||
result2 = a / c; //result2 vaut 6,0\end{verbatim}
|
||||
\end{exampleblock}}
|
||||
\end{frame}
|
||||
|
||||
17
operateurs/16.tex
Normal file
17
operateurs/16.tex
Normal file
|
|
@ -0,0 +1,17 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: L'opérateur \% (modulo)}
|
||||
|
||||
Cet opérateur retourne le reste de la division de son opérande gauche par son opérande droit.
|
||||
\vspace{0.5cm}
|
||||
\par
|
||||
Cet opérateur ne modifie pas la valeur de
|
||||
ses opérandes.
|
||||
\vspace{0.5cm}
|
||||
\begin{exampleblock}{Exemple d'utilisation de l'opérateur \%}
|
||||
\begin{verbatim}
|
||||
int a = 15, b = 6, c;
|
||||
c = a % b; // c vaut 3\end{verbatim}
|
||||
\end{exampleblock}
|
||||
\end{frame}
|
||||
|
||||
24
operateurs/17.tex
Normal file
24
operateurs/17.tex
Normal file
|
|
@ -0,0 +1,24 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: L'opérateur $<<$}
|
||||
|
||||
Cet opérateur retourne le décalage binaire à gauche de son opérande gauche de son opérande droit nombre de fois.
|
||||
\par
|
||||
Cet opérateur ne modifie pas la valeur de ses opérandes.
|
||||
\par
|
||||
Un décalage binaire à gauche signifie décaler tous les bits d'un rang vers la gauche, dans une représentation binaire de la variable. Le
|
||||
bit le plus à gauche est perdu, et le bit le plus à droite est à 0.
|
||||
\vspace{0.3cm}
|
||||
\par
|
||||
Par exemple, pour un \verb|unsigned char|, contenant 149, soit en binaire \texttt{10010101} (128 + 16 + 4 + 1), si on effectue 1 décalage
|
||||
à gauche, le nombre obtenu est 42, soit en binaire \texttt{00101010}.
|
||||
\vspace{0.3cm}
|
||||
\par
|
||||
\begin{exampleblock}{Example d'utilisation de l'opérateur $<<$}
|
||||
\begin{verbatim}
|
||||
int a = 149, b;
|
||||
b = a << 2; // la valeur de a subit deux décalages à gauche
|
||||
// b reçoit 84 (64 + 16 + 4)\end{verbatim}
|
||||
\end{exampleblock}
|
||||
\end{frame}
|
||||
|
||||
19
operateurs/18.tex
Normal file
19
operateurs/18.tex
Normal file
|
|
@ -0,0 +1,19 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: L'opérateur $>>$}
|
||||
|
||||
Cet opérateur retourne le décalage binaire à droite de son opérande gauche de son opérande droit nombre de fois.
|
||||
\par
|
||||
Cet opérateur ne modifie pas la valeur de ses opérandes.
|
||||
\vspace{0.3cm}
|
||||
\par
|
||||
Lorsqu'un décalage binaire à droite est effectué, le bit le plus à droite dans la représentation binaire est perdu, les bits sont tous décalés
|
||||
d'un rang à droite, et le bit le plus à gauche est à 0.
|
||||
\vspace{0.3cm}
|
||||
\begin{exampleblock}{Exemple d'utilisation de l'opérateur $>>$}
|
||||
\begin{verbatim}
|
||||
unsigned char a = 141, b; // 141 soit 10001101
|
||||
b = a >> 2; // b reçoit 35 soit 00100011\end{verbatim}
|
||||
\end{exampleblock}
|
||||
\end{frame}
|
||||
|
||||
28
operateurs/19.tex
Normal file
28
operateurs/19.tex
Normal file
|
|
@ -0,0 +1,28 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: L'opérateur \&}
|
||||
|
||||
Cet opérateur effectue un ``ET binaire'' (AND) de son opérateur gauche avec son opérateur droit. Cet opérateur n'altère pas ses opérandes.
|
||||
\vspace{0.3cm}
|
||||
\par
|
||||
Le AND binaire s'effectue bit à bit entre les deux opérandes.
|
||||
\par
|
||||
\begin{center}
|
||||
\begin{tabular}{|c|c|c|}
|
||||
\hline
|
||||
\& & 0 & 1 \\
|
||||
\hline
|
||||
0 & 0 & 0 \\
|
||||
\hline
|
||||
1 & 0 & 1 \\
|
||||
\hline
|
||||
\end{tabular}
|
||||
\end{center}
|
||||
\begin{exampleblock}{Exemple d'utilisation de l'opérateur \&}
|
||||
\begin{verbatim}
|
||||
int a = 42, b = 12, c;
|
||||
c = a & b; // c reçoit 00101010 & 00001100,
|
||||
// soit 00001000 => 8\end{verbatim}
|
||||
\end{exampleblock}
|
||||
\end{frame}
|
||||
|
||||
28
operateurs/20.tex
Normal file
28
operateurs/20.tex
Normal file
|
|
@ -0,0 +1,28 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: L'opérateur |}
|
||||
|
||||
Cet opérateur effectue un ``OU binaire'' (OR) de son opérateur gauche avec son opérateur droit. Cet opérateur n'altère pas ses opérandes.
|
||||
\vspace{0.3cm}
|
||||
\par
|
||||
Le OR binaire s'effectue bit à bit entre les deux opérandes.
|
||||
\par
|
||||
\begin{center}
|
||||
\begin{tabular}{|c|c|c|}
|
||||
\hline
|
||||
| & 0 & 1 \\
|
||||
\hline
|
||||
0 & 0 & 1 \\
|
||||
\hline
|
||||
1 & 1 & 1 \\
|
||||
\hline
|
||||
\end{tabular}
|
||||
\end{center}
|
||||
\begin{exampleblock}{Exemple d'utilisation de l'opérateur |}
|
||||
\begin{verbatim}
|
||||
int a = 42, b = 12, c;
|
||||
c = a | b; // c reçoit 00101010 | 00001100,
|
||||
// soit 00101110 => 46\end{verbatim}
|
||||
\end{exampleblock}
|
||||
\end{frame}
|
||||
|
||||
28
operateurs/21.tex
Normal file
28
operateurs/21.tex
Normal file
|
|
@ -0,0 +1,28 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: L'opérateur \^{ }}
|
||||
|
||||
Cet opérateur effectue un ``OU exclusif binaire'' (XOR) de son opérateur gauche avec son opérateur droit. Cet opérateur n'altère pas ses opérandes.
|
||||
\vspace{0.3cm}
|
||||
\par
|
||||
Le XOR binaire s'effectue bit à bit entre les deux opérandes.
|
||||
\par
|
||||
\begin{center}
|
||||
\begin{tabular}{|c|c|c|}
|
||||
\hline
|
||||
\^{ } & 0 & 1 \\
|
||||
\hline
|
||||
0 & 0 & 1 \\
|
||||
\hline
|
||||
1 & 1 & 0 \\
|
||||
\hline
|
||||
\end{tabular}
|
||||
\end{center}
|
||||
\begin{exampleblock}{Exemple d'utilisation de l'opérateur \^{ }}
|
||||
\begin{verbatim}
|
||||
int a = 42, b = 12, c;
|
||||
c = a ^ b; // c reçoit 00101010 & 00001100,
|
||||
// soit 00100110 => 38\end{verbatim}
|
||||
\end{exampleblock}
|
||||
\end{frame}
|
||||
|
||||
21
operateurs/22.tex
Normal file
21
operateurs/22.tex
Normal file
|
|
@ -0,0 +1,21 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: L'opérateur ==}
|
||||
|
||||
Cet opérateur retourne 1 (vrai) quand les deux opérandes sont égaux, 0 (faux) sinon. Cet opérande n'altère pas ses opérandes.
|
||||
\par
|
||||
\begin{alertblock}{L'erreur classique !}
|
||||
Une erreur classique des débutants est de ne mettre qu'un seul symbole = pour effectuer le test d'égalité. Dans ce cas, c'est l'affectation qui
|
||||
est faite, et qui renvoie, comme vu précédemment, l'opérande droit.
|
||||
\end{alertblock}
|
||||
\begin{exampleblock}{Utilisation de l'opérateur ==}
|
||||
\begin{verbatim}
|
||||
#include <stdbool.h>
|
||||
int a = 5, b = 5;
|
||||
char c = '5';
|
||||
bool test;
|
||||
test = a == b; // test vaut 1 (vrai)
|
||||
test = a == c; // test vaut 0 (faux) car '5' = 53 \end{verbatim}
|
||||
\end{exampleblock}
|
||||
\end{frame}
|
||||
|
||||
20
operateurs/23.tex
Normal file
20
operateurs/23.tex
Normal file
|
|
@ -0,0 +1,20 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: L'opérateur !=}
|
||||
|
||||
Cet opérateur retourne 0 (faux) quand les deux opérandes sont égaux, 1 (vrai) sinon. Cet opérande n'altère pas ses opérandes.
|
||||
\vspace{0.3cm}
|
||||
L'opérateur d'inégalité est équivalent à l'utilisation de l'opérateur d'égalité dont le résultat serait inversé à l'aide de l'opérateur
|
||||
non logique~: !
|
||||
\vspace{0.3cm}
|
||||
\begin{exampleblock}{Exemple d'utilisation de l'opérateur !=}
|
||||
\begin{verbatim}
|
||||
#include <stdbool.h>
|
||||
int a = 5, b = 7;
|
||||
bool c;
|
||||
c = a != b; // c vaut 1 (vrai)
|
||||
c = !(a == b); // c vaut 1 (vrai)
|
||||
c = !(a != b); // c vaut 0 (faux)\end{verbatim}
|
||||
\end{exampleblock}
|
||||
\end{frame}
|
||||
|
||||
17
operateurs/24.tex
Normal file
17
operateurs/24.tex
Normal file
|
|
@ -0,0 +1,17 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: L'opérateur $<$}
|
||||
|
||||
Cet opérateur renvoie 1 (vrai) lorsque l'opérande gauche est strictement inférieur à l'opérande droit, 0 (faux) sinon.
|
||||
\par
|
||||
Cet opérateur n'altère pas ses opérandes.
|
||||
\vspace{0.3cm}
|
||||
\begin{exampleblock}{Exemple d'utilisation de l'opérateur $<$}
|
||||
\begin{verbatim}
|
||||
#include <stdbool.h>
|
||||
int a = 5;
|
||||
bool c;
|
||||
c = a < 7; // c vaut 1 (vrai)\end{verbatim}
|
||||
\end{exampleblock}
|
||||
\end{frame}
|
||||
|
||||
18
operateurs/25.tex
Normal file
18
operateurs/25.tex
Normal file
|
|
@ -0,0 +1,18 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: L'opérateur $>$}
|
||||
|
||||
Cet opérateur renvoie 1 (vrai) lorsque l'opérande gauche est strictement supérieur à l'opérande droit, 0 (faux) sinon.
|
||||
\par
|
||||
Cet opérateur n'altère pas ses opérandes.
|
||||
\vspace{0.3cm}
|
||||
\begin{exampleblock}{Exemple d'utilisation de l'opérateur $>$}
|
||||
\begin{verbatim}
|
||||
#include <stdbool.h>
|
||||
int a = 5;
|
||||
bool c;
|
||||
c = a > 7; // c vaut 0 (faux)\end{verbatim}
|
||||
\end{exampleblock}
|
||||
|
||||
\end{frame}
|
||||
|
||||
18
operateurs/26.tex
Normal file
18
operateurs/26.tex
Normal file
|
|
@ -0,0 +1,18 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: L'opérateur $<$=}
|
||||
|
||||
Cet opérateur renvoie 1 (vrai) lorsque l'opérande gauche est inférieur ou égal à l'opérande droit, 0 (faux) sinon.
|
||||
\par
|
||||
Cet opérateur n'altère pas ses opérandes.
|
||||
\vspace{0.3cm}
|
||||
\begin{exampleblock}{Exemple d'utilisation de l'opérateur $<=$}
|
||||
\begin{verbatim}
|
||||
#include <stdbool.h>
|
||||
int a = 5;
|
||||
bool c;
|
||||
c = a <= 7; // c vaut 1 (vrai)
|
||||
c = a <= 5; // c vaut 1 (vrai)\end{verbatim}
|
||||
\end{exampleblock}
|
||||
\end{frame}
|
||||
|
||||
18
operateurs/27.tex
Normal file
18
operateurs/27.tex
Normal file
|
|
@ -0,0 +1,18 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: L'opérateur $>$=}
|
||||
|
||||
Cet opérateur renvoie 1 (vrai) lorsque l'opérande gauche est supérieur ou égal à l'opérande droit, 0 (faux) sinon.
|
||||
\par
|
||||
Cet opérateur n'altère pas ses opérandes.
|
||||
\vspace{0.3cm}
|
||||
\begin{exampleblock}{Exemple d'utilisation de l'opérateur $>=$}
|
||||
\begin{verbatim}
|
||||
#include <stdbool.h>
|
||||
int a = 5;
|
||||
bool c;
|
||||
c = a >= 7; // c vaut 0 (faux)
|
||||
c = a >= 5; // c vaut 1 (vrai)\end{verbatim}
|
||||
\end{exampleblock}
|
||||
\end{frame}
|
||||
|
||||
28
operateurs/28.tex
Normal file
28
operateurs/28.tex
Normal file
|
|
@ -0,0 +1,28 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: L'opérateur \&\&}
|
||||
|
||||
Cet opérateur représente l'opérateur ``ET logique''. Il retourne 1 si ses deux opérandes valent vrai (valeur non nulle), sinon 0 (faux).
|
||||
\par
|
||||
Cet opérateur n'altère pas ses opérandes.
|
||||
\vspace{0.5cm}
|
||||
\begin{center}
|
||||
\begin{tabular}{|c|c|c|}
|
||||
\hline
|
||||
\&\& & 0 & 1 \\
|
||||
\hline
|
||||
0 & 0 & 0 \\
|
||||
\hline
|
||||
1 & 0 & 1 \\
|
||||
\hline
|
||||
\end{tabular}
|
||||
\end{center}
|
||||
\begin{exampleblock}{Exemple d'utilisation de l'opérateur \&\&}
|
||||
\begin{verbatim}
|
||||
#include <stdbool.h>
|
||||
int a = 5, b = 8;
|
||||
bool c = (a < 7) && (b > 10); // c vaut 0 (faux)
|
||||
\end{verbatim}
|
||||
\end{exampleblock}
|
||||
\end{frame}
|
||||
|
||||
29
operateurs/29.tex
Normal file
29
operateurs/29.tex
Normal file
|
|
@ -0,0 +1,29 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: L'opérateur ||}
|
||||
|
||||
Cet opérateur représente l'opérateur ``OU logique''. Il retourne 1 si au moins l'un de ses deux opérandes vaut vrai (valeur non nulle),
|
||||
sinon 0 (faux).
|
||||
\par
|
||||
Cet opérateur n'altère pas ses opérandes.
|
||||
\vspace{0.5cm}
|
||||
\begin{center}
|
||||
\begin{tabular}{|c|c|c|}
|
||||
\hline
|
||||
|| & 0 & 1 \\
|
||||
\hline
|
||||
0 & 0 & 1 \\
|
||||
\hline
|
||||
1 & 1 & 1 \\
|
||||
\hline
|
||||
\end{tabular}
|
||||
\end{center}
|
||||
\begin{exampleblock}{Exemple d'utilisation de l'opérateur ||}
|
||||
\begin{verbatim}
|
||||
#include <stdbool.h>
|
||||
int a = 5, b = 8;
|
||||
bool c = (a < 7) || (b > 10); // c vaut 1 (vrai)
|
||||
\end{verbatim}
|
||||
\end{exampleblock}
|
||||
\end{frame}
|
||||
|
||||
23
operateurs/30.tex
Normal file
23
operateurs/30.tex
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: Les opérateur \&\& et ||~: Débranchement~I}
|
||||
|
||||
{\small\begin{alertblock}{Débranchement}
|
||||
Les opérateurs logiques ET et OU sont débranchants.
|
||||
\par
|
||||
Cela signifie que pour des raisons de performances, il a été décidé que si le premier opérande permet de décider à lui seul du résultat d'une
|
||||
opération impliquant l'un de ces deux opérateurs, alors le deuxième opérande n'est pas évalué !
|
||||
\vspace{0.3cm}
|
||||
\par
|
||||
Ne pas être évalué signifie que l'expression n'est pas du tout exécutée, et si des opérations altérant des variables ou des appels de fonction
|
||||
sont effectués dans le deuxième opérande, ces instructions n'ont pas lieu.
|
||||
\vspace{0.3cm}
|
||||
\par
|
||||
Le cas se produit si le premier opérande d'un ET logique est faux~: quelque soit la valeur du second résultat, le résultat est nécessairement
|
||||
faux.
|
||||
\par
|
||||
Le cas se produit également si le premier opérande d'un OU logique est faux~: quelque soit la valeur du second résultat, le résultat est
|
||||
nécessairement vrai.
|
||||
\end{alertblock}}
|
||||
\end{frame}
|
||||
|
||||
21
operateurs/31.tex
Normal file
21
operateurs/31.tex
Normal file
|
|
@ -0,0 +1,21 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: Les opérateur \&\& et ||~: Débranchement~II}
|
||||
|
||||
\begin{exampleblock}{Exemples de débranchements}
|
||||
\begin{verbatim}
|
||||
#include <stdbool.h>
|
||||
int a = 5, b = 6, c = 0;
|
||||
bool t;
|
||||
|
||||
t = (a < 9) || ( (c = 5) < b);
|
||||
// t vaut 1, a vaut 5, b vaut 6, c vaut 0
|
||||
|
||||
t = (a > 9) && ( (c = 5) < b);
|
||||
// t vaut 0, a vaut 5, b vaut 6, c vaut 0
|
||||
|
||||
t = (a < 9) && ( (c = 5) < b);
|
||||
// t vaut 1, a vaut 5, b vaut 6, c vaut 5\end{verbatim}
|
||||
\end{exampleblock}
|
||||
\end{frame}
|
||||
|
||||
26
operateurs/32.tex
Normal file
26
operateurs/32.tex
Normal file
|
|
@ -0,0 +1,26 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: Les opérateurs de calculs et d'affectations simultanés}
|
||||
|
||||
La plupart des opérateurs de calcul possèdent un raccourci quand le résultat de l'opération est affecté à une variable qui se trouve être son opérande gauche.
|
||||
\vspace{0.3cm}
|
||||
\par
|
||||
Dans ce cas, on utilise également un opérateur d'arité 2, dont la syntaxe est le symbole de l'opération désirée suivi du symbole ``=''. L'opérande de gauche subit
|
||||
l'opération avec l'opérande droit et reçoit le résultat de cette opération.
|
||||
\begin{exampleblock}{Exemple de l'addition}
|
||||
\begin{verbatim}
|
||||
int a = 5;
|
||||
a += 2; // équivalent à a = a + 2\end{verbatim}
|
||||
\end{exampleblock}
|
||||
Voici la liste des opérateurs permettant ce raccourci~:
|
||||
\begin{center}
|
||||
\begin{tabular}{|>{\centering\arraybackslash}m{1.5cm}|>{\centering\arraybackslash}m{1.5cm}|>{\centering\arraybackslash}m{1.5cm}|>{\centering\arraybackslash}m{1.5cm}|>{\centering\arraybackslash}m{1.5cm}|}
|
||||
\hline
|
||||
+= & -= & *= & /= & \%= \\
|
||||
\hline
|
||||
\&= & |= & \^{ }= & $<<$= & $>>$= \\
|
||||
\hline
|
||||
\end{tabular}
|
||||
\end{center}
|
||||
\end{frame}
|
||||
|
||||
38
operateurs/33.tex
Normal file
38
operateurs/33.tex
Normal file
|
|
@ -0,0 +1,38 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: Bibliothèque iso646.h}
|
||||
|
||||
La norme C95 a défini des alias pour certains opérateurs, notamment pour aider à la lisibilité et pour pouvoir saisir du code sur des claviers ne disposant pas de
|
||||
certains caractères\ldots
|
||||
\vspace{0.3cm}
|
||||
\par
|
||||
Le fichier entête \verb|<iso646.h>| définit ces macros.
|
||||
\begin{center}
|
||||
{\small\begin{tabular}{|c|c|}
|
||||
\hline
|
||||
\verb|and| & \&\& \\
|
||||
\hline
|
||||
\verb|and_eq| & \&= \\
|
||||
\hline
|
||||
\verb|or| & || \\
|
||||
\hline
|
||||
\verb|or_eq| & |= \\
|
||||
\hline
|
||||
\verb|bitand| & \& \\
|
||||
\hline
|
||||
\verb|bitor| & | \\
|
||||
\hline
|
||||
\verb|compl| & $\sim$ \\
|
||||
\hline
|
||||
\verb|not| & ! \\
|
||||
\hline
|
||||
\verb|not_eq| & != \\
|
||||
\hline
|
||||
\verb|xor| & \^{ } \\
|
||||
\hline
|
||||
\verb|xor_eq| & \^{ }= \\
|
||||
\hline
|
||||
\end{tabular}}
|
||||
\end{center}
|
||||
\end{frame}
|
||||
|
||||
17
operateurs/34.tex
Normal file
17
operateurs/34.tex
Normal file
|
|
@ -0,0 +1,17 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: L'opérateur ?:}
|
||||
|
||||
Cet opérateur utilise 3 opérandes. Il renvoie le deuxième opérande si la valeur du premier est vrai (valeur non nulle), et sinon il renvoie le troisième.
|
||||
\par
|
||||
L'opérande qui n'est pas renvoyé n'est pas évalué (et son code n'est donc pas exécuté).
|
||||
\vspace{0.3cm}
|
||||
\begin{exampleblock}{Exemple d'utilisation de l'opérateur ternaire ?:}
|
||||
\begin{verbatim}
|
||||
int a = 2, b;
|
||||
b = a < 5 ? 3 : 6; // b reçoit 3
|
||||
b = (a < 1 || a > 5) ? 5: 9; // b reçoit 9
|
||||
b = a ? a + 5 : 0; // si a non nul, b reçoit a + 5, sinon 0\end{verbatim}
|
||||
\end{exampleblock}
|
||||
\end{frame}
|
||||
|
||||
37
operateurs/35.tex
Normal file
37
operateurs/35.tex
Normal file
|
|
@ -0,0 +1,37 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: Les opérateurs de calculs et d'affectations simultanés}
|
||||
|
||||
Comme en mathématique où l'on résout les multiplications avant les additions, excepté si des parenthèse modifient l'ordre de résolution, il existe un ordre de priorité
|
||||
des opérateurs en C. Voici les priorités par ordre décroissant de priorité~:
|
||||
\begin{center}
|
||||
{\footnotesize\begin{tabular}{|c|c|c|c|c|c|c|c|c|c|c|}
|
||||
\hline
|
||||
-- & ++ & ! & $\sim$val & -val & & & & & & \\
|
||||
\hline
|
||||
* & / & \% & & & & & & & & \\
|
||||
\hline
|
||||
+ & - & & & & & & & & & \\
|
||||
\hline
|
||||
$<<$ & $>>$ & & & & & & & & & \\
|
||||
\hline
|
||||
< & <= & >= & > & & & & & & & \\
|
||||
\hline
|
||||
== & != & & & & & & & & & \\
|
||||
\hline
|
||||
\& & & & & & & & & & & \\
|
||||
\hline
|
||||
\^{ } & & & & & & & & & & \\
|
||||
\hline
|
||||
| & & & & & & & & & & \\
|
||||
\hline
|
||||
\&\& & || & & & & & & & & & \\
|
||||
\hline
|
||||
?: & & & & & & & & & & \\
|
||||
\hline
|
||||
= & += & -= & *= & /= & \%= & \&= & |= & \^{ }= & $<<$= & $>>$= \\
|
||||
\hline
|
||||
\end{tabular}}
|
||||
\end{center}
|
||||
\end{frame}
|
||||
|
||||
79
operateurs/operateurs.tex
Normal file
79
operateurs/operateurs.tex
Normal file
|
|
@ -0,0 +1,79 @@
|
|||
\subsection*{Les opérateurs d'arité 1}
|
||||
|
||||
\input{operateurs/01}
|
||||
|
||||
\input{operateurs/02}
|
||||
|
||||
\input{operateurs/03}
|
||||
|
||||
\input{operateurs/04}
|
||||
|
||||
\input{operateurs/05}
|
||||
|
||||
\input{operateurs/06}
|
||||
|
||||
\subsection*{Les opérateurs d'arité 2}
|
||||
|
||||
\input{operateurs/07}
|
||||
|
||||
\input{operateurs/08}
|
||||
|
||||
\input{operateurs/09}
|
||||
|
||||
\input{operateurs/10}
|
||||
|
||||
\input{operateurs/11}
|
||||
|
||||
\input{operateurs/12}
|
||||
|
||||
\input{operateurs/12-1}
|
||||
|
||||
\input{operateurs/13}
|
||||
|
||||
\input{operateurs/14}
|
||||
|
||||
\input{operateurs/15}
|
||||
|
||||
\input{operateurs/16}
|
||||
|
||||
\input{operateurs/17}
|
||||
|
||||
\input{operateurs/18}
|
||||
|
||||
\input{operateurs/19}
|
||||
|
||||
\input{operateurs/20}
|
||||
|
||||
\input{operateurs/21}
|
||||
|
||||
\input{operateurs/22}
|
||||
|
||||
\input{operateurs/23}
|
||||
|
||||
\input{operateurs/24}
|
||||
|
||||
\input{operateurs/25}
|
||||
|
||||
\input{operateurs/26}
|
||||
|
||||
\input{operateurs/27}
|
||||
|
||||
\input{operateurs/28}
|
||||
|
||||
\input{operateurs/29}
|
||||
|
||||
\input{operateurs/30}
|
||||
|
||||
\input{operateurs/31}
|
||||
|
||||
\input{operateurs/32}
|
||||
|
||||
\input{operateurs/33}
|
||||
|
||||
\subsection*{L'opérateur d'arité 3}
|
||||
|
||||
\input{operateurs/34}
|
||||
|
||||
\subsection*{Priorité des opérateurs}
|
||||
|
||||
\input{operateurs/35}
|
||||
BIN
pointeurs/._pointeurs.tex
Normal file
BIN
pointeurs/._pointeurs.tex
Normal file
Binary file not shown.
19
pointeurs/01.tex
Normal file
19
pointeurs/01.tex
Normal file
|
|
@ -0,0 +1,19 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~I}
|
||||
|
||||
Les pointeurs sont un nouveau type de données. Ils se déclarent à peu près avec la même syntaxe que des variables standards.
|
||||
\vspace{0.5cm}
|
||||
\par
|
||||
Il existe un type de pointeurs pour chaque type de données (primitifs ou non).
|
||||
\vspace{0.5cm}
|
||||
\par
|
||||
On peut déclarer une variable de type ``pointeur d'un certain type'' en intercalant le symbole \texttt{*} entre le type de données et
|
||||
l'identificateur de la variable.
|
||||
\vspace{0.5cm}
|
||||
\begin{block}{Syntaxe générale de la déclaration de pointeur}
|
||||
\begin{verbatim}
|
||||
type_variable * identificateurVariable;\end{verbatim}
|
||||
\end{block}
|
||||
\end{frame}
|
||||
|
||||
20
pointeurs/02.tex
Normal file
20
pointeurs/02.tex
Normal file
|
|
@ -0,0 +1,20 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~II}
|
||||
|
||||
\begin{exampleblock}{Déclaration d'un pointeur sur short}
|
||||
\begin{verbatim}
|
||||
short * pnMonPointeur;\end{verbatim}
|
||||
\end{exampleblock}
|
||||
\vspace{0.3cm}
|
||||
\begin{exampleblock}{Déclaration d'un pointeur sur structure}
|
||||
\begin{verbatim}
|
||||
struct Date * pMaDate;\end{verbatim}
|
||||
\end{exampleblock}
|
||||
\vspace{0.3cm}
|
||||
\begin{exampleblock}{Déclaration d'un pointeur sur un pointeur d'int}
|
||||
\begin{verbatim}
|
||||
int ** ppiFirstElement;\end{verbatim}
|
||||
\end{exampleblock}
|
||||
\end{frame}
|
||||
|
||||
16
pointeurs/03.tex
Normal file
16
pointeurs/03.tex
Normal file
|
|
@ -0,0 +1,16 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~III}
|
||||
|
||||
Il est possible de déclarer plusieurs pointeurs sur une même ligne, voire de mixer pointeurs et type normal.
|
||||
\vspace{0.5cm}
|
||||
\par
|
||||
Dans ce cas, il faut faire précéder l'identificateur d'un astérisque à chaque fois qu'on veut un pointeur.
|
||||
\begin{exampleblock}{Déclaration de plusieurs variables dont des pointeurs}
|
||||
\begin{verbatim}
|
||||
int *a, b, *c;\end{verbatim}
|
||||
\end{exampleblock}
|
||||
\par
|
||||
Dans cet exemple, \texttt{a} et \texttt{c} sont des pointeurs sur int (type \texttt{int *}), et \texttt{b} est un int.
|
||||
\end{frame}
|
||||
|
||||
18
pointeurs/04.tex
Normal file
18
pointeurs/04.tex
Normal file
|
|
@ -0,0 +1,18 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~IV}
|
||||
|
||||
Tout comme les variables, les pointeurs doivent être initialisés avant d'être utilisés~!
|
||||
\vspace{0.5cm}
|
||||
\par
|
||||
Un pointeur peut être considéré comme vide, ou ne ``pointant'' sur rien si sa valeur est égale à la macro NULL (disponible dans
|
||||
$<$stdlib.h$>$).
|
||||
|
||||
\begin{exampleblock}{Initialisation d'un pointeur à NULL}
|
||||
\begin{verbatim}
|
||||
int * p_i = NULL;
|
||||
char * szMyName;
|
||||
szMyName = NULL;\end{verbatim}
|
||||
\end{exampleblock}
|
||||
\end{frame}
|
||||
|
||||
18
pointeurs/05.tex
Normal file
18
pointeurs/05.tex
Normal file
|
|
@ -0,0 +1,18 @@
|
|||
\begin{frame}%[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: L'opérateur \&~I}
|
||||
|
||||
L'opérateur \& permet de récupérer l'adresse mémoire à laquelle est stockée la valeur d'une variable.
|
||||
\vspace{0.5cm}
|
||||
\par
|
||||
Lorsqu'on déclare une variable, on alloue plus ou moins d'octets en mémoire, en fonction du type de la variable.
|
||||
Si l'on met l'opérateur \& devant le nom de cette variable, lors de l'évaluation d'une expression, ce n'est plus le contenu de la
|
||||
variable qui est retourné, mais l'adresse mémoire à laquelle il est stocké.
|
||||
\vspace{0.5cm}
|
||||
\par
|
||||
Si le type de données de la variable est stocké sur plusieurs octets, c'est l'adresse mémoire du premier octet qui est retourné.
|
||||
\vspace{0.5cm}
|
||||
\par
|
||||
Le type de données renvoyé par une variable précédée de l'opérateur \& est un pointeur sur le type de données de la variable.
|
||||
\end{frame}
|
||||
|
||||
15
pointeurs/06.tex
Normal file
15
pointeurs/06.tex
Normal file
|
|
@ -0,0 +1,15 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: L'opérateur \&~II}
|
||||
|
||||
\begin{block}{Syntaxe générale de l'opérateur \&}
|
||||
\begin{verbatim}
|
||||
&identificateur\end{verbatim}
|
||||
\end{block}
|
||||
\begin{exampleblock}{Exemple de récupération de l'adresse d'un int}
|
||||
\begin{verbatim}
|
||||
int * pointer, value = 5;
|
||||
pointer = &value; // L'expression &value est de type int *\end{verbatim}
|
||||
\end{exampleblock}
|
||||
\end{frame}
|
||||
|
||||
19
pointeurs/07.tex
Normal file
19
pointeurs/07.tex
Normal file
|
|
@ -0,0 +1,19 @@
|
|||
\begin{frame}[containsverbatim]
|
||||
\frametitle{\secname}
|
||||
\framesubtitle{\subsecname~: L'opérateur *~I}
|
||||
|
||||
L'opérateur unaire (d'arité 1 donc\ldots) * permet d'accéder à la valeur stockée à l'adresse pointée par un pointeur. On appelle cette
|
||||
opération le \textbf{déréférencement}.
|
||||
|
||||
\begin{block}{Syntaxe générale de l'opérateur *}
|
||||
\begin{verbatim}
|
||||
*pointeur\end{verbatim}
|
||||
\end{block}
|
||||
|
||||
\begin{alertblock}{NULL-pointer derefenrencing}
|
||||
Vous NE DEVEZ PAS déréférencer un pointeur contenant NULL ! Ce peut constituer une faille de sécurité importante.
|
||||
\par
|
||||
Vous DEVEZ tester que la valeur est non-nulle avant de déréférencer un pointeur, s'il y a un doute possible.
|
||||
\end{alertblock}
|
||||
\end{frame}
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Reference in a new issue