From 0b4615ed74a336dbc7567ef7f266df2fe5bce825 Mon Sep 17 00:00:00 2001 From: Florian Maury Date: Mon, 24 Feb 2014 18:38:56 +0100 Subject: [PATCH] initial --- CoursC.tex | 84 ++++++++++ SujetTP2011.tex | 75 +++++++++ TD1.tex | 86 ++++++++++ TD2.tex | 139 +++++++++++++++++ TD3.tex | 183 ++++++++++++++++++++++ TP1-2011.tex | 88 +++++++++++ TP2.tex | 286 ++++++++++++++++++++++++++++++++++ branchements/01.tex | 21 +++ branchements/02.tex | 17 ++ branchements/03.tex | 24 +++ branchements/04.tex | 17 ++ branchements/05.tex | 23 +++ branchements/06.tex | 21 +++ branchements/07.tex | 19 +++ branchements/08.tex | 24 +++ branchements/09.tex | 22 +++ branchements/10.tex | 21 +++ branchements/11.tex | 21 +++ branchements/12.tex | 22 +++ branchements/13.tex | 24 +++ branchements/14.tex | 24 +++ branchements/15.tex | 26 ++++ branchements/16.tex | 20 +++ branchements/17.tex | 10 ++ branchements/18.tex | 23 +++ branchements/19.tex | 25 +++ branchements/20.tex | 18 +++ branchements/21.tex | 14 ++ branchements/22.tex | 16 ++ branchements/23.tex | 18 +++ branchements/24.tex | 14 ++ branchements/25.tex | 16 ++ branchements/26.tex | 17 ++ branchements/27.tex | 16 ++ branchements/28.tex | 16 ++ branchements/29.tex | 23 +++ branchements/30.tex | 19 +++ branchements/31.tex | 23 +++ branchements/32.tex | 12 ++ branchements/33.tex | 12 ++ branchements/34.tex | 17 ++ branchements/branchements.tex | 83 ++++++++++ generalites/01.tex | 7 + generalites/02.tex | 14 ++ generalites/03.tex | 19 +++ generalites/04.tex | 16 ++ generalites/05.tex | 17 ++ generalites/06.tex | 18 +++ generalites/07.tex | 16 ++ generalites/08.tex | 15 ++ generalites/09.tex | 17 ++ generalites/10.tex | 16 ++ generalites/11.tex | 17 ++ generalites/12.tex | 18 +++ generalites/generalites.tex | 35 +++++ operateurs/01.tex | 23 +++ operateurs/02.tex | 23 +++ operateurs/03.tex | 17 ++ operateurs/04.tex | 23 +++ operateurs/05.tex | 24 +++ operateurs/06.tex | 11 ++ operateurs/07.tex | 14 ++ operateurs/08.tex | 14 ++ operateurs/09.tex | 15 ++ operateurs/10.tex | 20 +++ operateurs/11.tex | 22 +++ operateurs/12-1.tex | 21 +++ operateurs/12.tex | 24 +++ operateurs/13.tex | 16 ++ operateurs/14.tex | 20 +++ operateurs/15.tex | 23 +++ operateurs/16.tex | 17 ++ operateurs/17.tex | 24 +++ operateurs/18.tex | 19 +++ operateurs/19.tex | 28 ++++ operateurs/20.tex | 28 ++++ operateurs/21.tex | 28 ++++ operateurs/22.tex | 21 +++ operateurs/23.tex | 20 +++ operateurs/24.tex | 17 ++ operateurs/25.tex | 18 +++ operateurs/26.tex | 18 +++ operateurs/27.tex | 18 +++ operateurs/28.tex | 28 ++++ operateurs/29.tex | 29 ++++ operateurs/30.tex | 23 +++ operateurs/31.tex | 21 +++ operateurs/32.tex | 26 ++++ operateurs/33.tex | 38 +++++ operateurs/34.tex | 17 ++ operateurs/35.tex | 37 +++++ operateurs/operateurs.tex | 79 ++++++++++ pointeurs/._pointeurs.tex | Bin 0 -> 4096 bytes pointeurs/01.tex | 19 +++ pointeurs/02.tex | 20 +++ pointeurs/03.tex | 16 ++ pointeurs/04.tex | 18 +++ pointeurs/05.tex | 18 +++ pointeurs/06.tex | 15 ++ pointeurs/07.tex | 19 +++ pointeurs/08.tex | 19 +++ pointeurs/09.tex | 19 +++ pointeurs/10.tex | 20 +++ pointeurs/11.tex | 22 +++ pointeurs/12.tex | 23 +++ pointeurs/13.tex | 14 ++ pointeurs/14.tex | 22 +++ pointeurs/15.tex | 12 ++ pointeurs/16.tex | 22 +++ pointeurs/17.tex | 15 ++ pointeurs/18.tex | 23 +++ pointeurs/19.tex | 21 +++ pointeurs/20.tex | 12 ++ pointeurs/21.tex | 17 ++ pointeurs/22.tex | 22 +++ pointeurs/23.tex | 20 +++ pointeurs/24.tex | 15 ++ pointeurs/25.tex | 21 +++ pointeurs/27.tex | 20 +++ pointeurs/28.tex | 19 +++ pointeurs/29.tex | 15 ++ pointeurs/30.tex | 19 +++ pointeurs/31.tex | 16 ++ pointeurs/32.tex | 19 +++ pointeurs/33.tex | 20 +++ pointeurs/34.tex | 13 ++ pointeurs/35.tex | 22 +++ pointeurs/36.tex | 19 +++ pointeurs/37.tex | 19 +++ pointeurs/38.tex | 17 ++ pointeurs/39.tex | 19 +++ pointeurs/40.tex | 12 ++ pointeurs/41.tex | 16 ++ pointeurs/42.tex | 14 ++ pointeurs/43.tex | 23 +++ pointeurs/44.tex | 17 ++ pointeurs/45.tex | 14 ++ pointeurs/46.tex | 28 ++++ pointeurs/47.tex | 17 ++ pointeurs/pointeurs.tex | 107 +++++++++++++ structure/01.tex | 19 +++ structure/02.tex | 13 ++ structure/03.tex | 11 ++ structure/04.tex | 22 +++ structure/05.tex | 21 +++ structure/06.tex | 22 +++ structure/07.tex | 26 ++++ structure/08.tex | 18 +++ structure/09.tex | 20 +++ structure/10.tex | 16 ++ structure/11.tex | 18 +++ structure/12.tex | 14 ++ structure/13.tex | 16 ++ structure/14.tex | 12 ++ structure/15.tex | 13 ++ structure/16.tex | 22 +++ structure/17.tex | 19 +++ structure/18.tex | 21 +++ structure/19.tex | 12 ++ structure/20.tex | 12 ++ structure/21.tex | 23 +++ structure/22.tex | 18 +++ structure/23.tex | 16 ++ structure/24.tex | 14 ++ structure/25.tex | 21 +++ structure/structure.tex | 67 ++++++++ variables/01.tex | 13 ++ variables/02.tex | 14 ++ variables/03.tex | 16 ++ variables/04.tex | 20 +++ variables/05.tex | 21 +++ variables/06.tex | 13 ++ variables/07.tex | 13 ++ variables/08.tex | 18 +++ variables/09.tex | 22 +++ variables/10.tex | 15 ++ variables/11.tex | 14 ++ variables/12.tex | 23 +++ variables/13.tex | 17 ++ variables/14.tex | 24 +++ variables/15.tex | 10 ++ variables/16.tex | 29 ++++ variables/17.tex | 22 +++ variables/18.tex | 17 ++ variables/19.tex | 20 +++ variables/20.tex | 18 +++ variables/21.tex | 21 +++ variables/22.tex | 19 +++ variables/23.tex | 20 +++ variables/24.tex | 23 +++ variables/25.tex | 32 ++++ variables/26.tex | 19 +++ variables/27-1.tex | 20 +++ variables/27.tex | 17 ++ variables/28.tex | 21 +++ variables/29.tex | 35 +++++ variables/30.tex | 17 ++ variables/31.tex | 18 +++ variables/32.tex | 20 +++ variables/33.tex | 18 +++ variables/34.tex | 23 +++ variables/35.tex | 18 +++ variables/36.tex | 22 +++ variables/37.tex | 17 ++ variables/38.tex | 31 ++++ variables/39.tex | 20 +++ variables/40.tex | 18 +++ variables/41.tex | 24 +++ variables/42.tex | 21 +++ variables/43.tex | 22 +++ variables/44.tex | 17 ++ variables/45.tex | 20 +++ variables/46.tex | 20 +++ variables/47.tex | 13 ++ variables/48.tex | 25 +++ variables/49.tex | 22 +++ variables/50.tex | 19 +++ variables/51.tex | 18 +++ variables/52.tex | 20 +++ variables/53.tex | 21 +++ variables/54.tex | 23 +++ variables/55.tex | 21 +++ variables/56.tex | 17 ++ variables/57.tex | 19 +++ variables/58.tex | 22 +++ variables/59.tex | 23 +++ variables/variables.tex | 137 ++++++++++++++++ 227 files changed, 5555 insertions(+) create mode 100644 CoursC.tex create mode 100644 SujetTP2011.tex create mode 100644 TD1.tex create mode 100644 TD2.tex create mode 100644 TD3.tex create mode 100644 TP1-2011.tex create mode 100644 TP2.tex create mode 100644 branchements/01.tex create mode 100644 branchements/02.tex create mode 100644 branchements/03.tex create mode 100644 branchements/04.tex create mode 100644 branchements/05.tex create mode 100644 branchements/06.tex create mode 100644 branchements/07.tex create mode 100644 branchements/08.tex create mode 100644 branchements/09.tex create mode 100644 branchements/10.tex create mode 100644 branchements/11.tex create mode 100644 branchements/12.tex create mode 100644 branchements/13.tex create mode 100644 branchements/14.tex create mode 100644 branchements/15.tex create mode 100644 branchements/16.tex create mode 100644 branchements/17.tex create mode 100644 branchements/18.tex create mode 100644 branchements/19.tex create mode 100644 branchements/20.tex create mode 100644 branchements/21.tex create mode 100644 branchements/22.tex create mode 100644 branchements/23.tex create mode 100644 branchements/24.tex create mode 100644 branchements/25.tex create mode 100644 branchements/26.tex create mode 100644 branchements/27.tex create mode 100644 branchements/28.tex create mode 100644 branchements/29.tex create mode 100644 branchements/30.tex create mode 100644 branchements/31.tex create mode 100644 branchements/32.tex create mode 100644 branchements/33.tex create mode 100644 branchements/34.tex create mode 100644 branchements/branchements.tex create mode 100644 generalites/01.tex create mode 100644 generalites/02.tex create mode 100644 generalites/03.tex create mode 100644 generalites/04.tex create mode 100644 generalites/05.tex create mode 100644 generalites/06.tex create mode 100644 generalites/07.tex create mode 100644 generalites/08.tex create mode 100644 generalites/09.tex create mode 100644 generalites/10.tex create mode 100644 generalites/11.tex create mode 100644 generalites/12.tex create mode 100644 generalites/generalites.tex create mode 100644 operateurs/01.tex create mode 100644 operateurs/02.tex create mode 100644 operateurs/03.tex create mode 100644 operateurs/04.tex create mode 100644 operateurs/05.tex create mode 100644 operateurs/06.tex create mode 100644 operateurs/07.tex create mode 100644 operateurs/08.tex create mode 100644 operateurs/09.tex create mode 100644 operateurs/10.tex create mode 100644 operateurs/11.tex create mode 100644 operateurs/12-1.tex create mode 100644 operateurs/12.tex create mode 100644 operateurs/13.tex create mode 100644 operateurs/14.tex create mode 100644 operateurs/15.tex create mode 100644 operateurs/16.tex create mode 100644 operateurs/17.tex create mode 100644 operateurs/18.tex create mode 100644 operateurs/19.tex create mode 100644 operateurs/20.tex create mode 100644 operateurs/21.tex create mode 100644 operateurs/22.tex create mode 100644 operateurs/23.tex create mode 100644 operateurs/24.tex create mode 100644 operateurs/25.tex create mode 100644 operateurs/26.tex create mode 100644 operateurs/27.tex create mode 100644 operateurs/28.tex create mode 100644 operateurs/29.tex create mode 100644 operateurs/30.tex create mode 100644 operateurs/31.tex create mode 100644 operateurs/32.tex create mode 100644 operateurs/33.tex create mode 100644 operateurs/34.tex create mode 100644 operateurs/35.tex create mode 100644 operateurs/operateurs.tex create mode 100644 pointeurs/._pointeurs.tex create mode 100644 pointeurs/01.tex create mode 100644 pointeurs/02.tex create mode 100644 pointeurs/03.tex create mode 100644 pointeurs/04.tex create mode 100644 pointeurs/05.tex create mode 100644 pointeurs/06.tex create mode 100644 pointeurs/07.tex create mode 100644 pointeurs/08.tex create mode 100644 pointeurs/09.tex create mode 100644 pointeurs/10.tex create mode 100644 pointeurs/11.tex create mode 100644 pointeurs/12.tex create mode 100644 pointeurs/13.tex create mode 100644 pointeurs/14.tex create mode 100644 pointeurs/15.tex create mode 100644 pointeurs/16.tex create mode 100644 pointeurs/17.tex create mode 100644 pointeurs/18.tex create mode 100644 pointeurs/19.tex create mode 100644 pointeurs/20.tex create mode 100644 pointeurs/21.tex create mode 100644 pointeurs/22.tex create mode 100644 pointeurs/23.tex create mode 100644 pointeurs/24.tex create mode 100644 pointeurs/25.tex create mode 100644 pointeurs/27.tex create mode 100644 pointeurs/28.tex create mode 100644 pointeurs/29.tex create mode 100644 pointeurs/30.tex create mode 100644 pointeurs/31.tex create mode 100644 pointeurs/32.tex create mode 100644 pointeurs/33.tex create mode 100644 pointeurs/34.tex create mode 100644 pointeurs/35.tex create mode 100644 pointeurs/36.tex create mode 100644 pointeurs/37.tex create mode 100644 pointeurs/38.tex create mode 100644 pointeurs/39.tex create mode 100644 pointeurs/40.tex create mode 100644 pointeurs/41.tex create mode 100644 pointeurs/42.tex create mode 100644 pointeurs/43.tex create mode 100644 pointeurs/44.tex create mode 100644 pointeurs/45.tex create mode 100644 pointeurs/46.tex create mode 100644 pointeurs/47.tex create mode 100644 pointeurs/pointeurs.tex create mode 100644 structure/01.tex create mode 100644 structure/02.tex create mode 100644 structure/03.tex create mode 100644 structure/04.tex create mode 100644 structure/05.tex create mode 100644 structure/06.tex create mode 100644 structure/07.tex create mode 100644 structure/08.tex create mode 100644 structure/09.tex create mode 100644 structure/10.tex create mode 100644 structure/11.tex create mode 100644 structure/12.tex create mode 100644 structure/13.tex create mode 100644 structure/14.tex create mode 100644 structure/15.tex create mode 100644 structure/16.tex create mode 100644 structure/17.tex create mode 100644 structure/18.tex create mode 100644 structure/19.tex create mode 100644 structure/20.tex create mode 100644 structure/21.tex create mode 100644 structure/22.tex create mode 100644 structure/23.tex create mode 100644 structure/24.tex create mode 100644 structure/25.tex create mode 100644 structure/structure.tex create mode 100644 variables/01.tex create mode 100644 variables/02.tex create mode 100644 variables/03.tex create mode 100644 variables/04.tex create mode 100644 variables/05.tex create mode 100644 variables/06.tex create mode 100644 variables/07.tex create mode 100644 variables/08.tex create mode 100644 variables/09.tex create mode 100644 variables/10.tex create mode 100644 variables/11.tex create mode 100644 variables/12.tex create mode 100644 variables/13.tex create mode 100644 variables/14.tex create mode 100644 variables/15.tex create mode 100644 variables/16.tex create mode 100644 variables/17.tex create mode 100644 variables/18.tex create mode 100644 variables/19.tex create mode 100644 variables/20.tex create mode 100644 variables/21.tex create mode 100644 variables/22.tex create mode 100644 variables/23.tex create mode 100644 variables/24.tex create mode 100644 variables/25.tex create mode 100644 variables/26.tex create mode 100644 variables/27-1.tex create mode 100644 variables/27.tex create mode 100644 variables/28.tex create mode 100644 variables/29.tex create mode 100644 variables/30.tex create mode 100644 variables/31.tex create mode 100644 variables/32.tex create mode 100644 variables/33.tex create mode 100644 variables/34.tex create mode 100644 variables/35.tex create mode 100644 variables/36.tex create mode 100644 variables/37.tex create mode 100644 variables/38.tex create mode 100644 variables/39.tex create mode 100644 variables/40.tex create mode 100644 variables/41.tex create mode 100644 variables/42.tex create mode 100644 variables/43.tex create mode 100644 variables/44.tex create mode 100644 variables/45.tex create mode 100644 variables/46.tex create mode 100644 variables/47.tex create mode 100644 variables/48.tex create mode 100644 variables/49.tex create mode 100644 variables/50.tex create mode 100644 variables/51.tex create mode 100644 variables/52.tex create mode 100644 variables/53.tex create mode 100644 variables/54.tex create mode 100644 variables/55.tex create mode 100644 variables/56.tex create mode 100644 variables/57.tex create mode 100644 variables/58.tex create mode 100644 variables/59.tex create mode 100644 variables/variables.tex diff --git a/CoursC.tex b/CoursC.tex new file mode 100644 index 0000000..84f696e --- /dev/null +++ b/CoursC.tex @@ -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} diff --git a/SujetTP2011.tex b/SujetTP2011.tex new file mode 100644 index 0000000..6da2a6c --- /dev/null +++ b/SujetTP2011.tex @@ -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} + + diff --git a/TD1.tex b/TD1.tex new file mode 100644 index 0000000..76d3c0d --- /dev/null +++ b/TD1.tex @@ -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 +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} diff --git a/TD2.tex b/TD2.tex new file mode 100644 index 0000000..b16e40b --- /dev/null +++ b/TD2.tex @@ -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} \ No newline at end of file diff --git a/TD3.tex b/TD3.tex new file mode 100644 index 0000000..1f1d144 --- /dev/null +++ b/TD3.tex @@ -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} \ No newline at end of file diff --git a/TP1-2011.tex b/TP1-2011.tex new file mode 100644 index 0000000..e2fc2c7 --- /dev/null +++ b/TP1-2011.tex @@ -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 + +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} diff --git a/TP2.tex b/TP2.tex new file mode 100644 index 0000000..624e0ae --- /dev/null +++ b/TP2.tex @@ -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 +%#endif +% +%#include +%#include +%#include +%#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} diff --git a/branchements/01.tex b/branchements/01.tex new file mode 100644 index 0000000..aaaf932 --- /dev/null +++ b/branchements/01.tex @@ -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} + diff --git a/branchements/02.tex b/branchements/02.tex new file mode 100644 index 0000000..7a4bbe4 --- /dev/null +++ b/branchements/02.tex @@ -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} + diff --git a/branchements/03.tex b/branchements/03.tex new file mode 100644 index 0000000..25162c3 --- /dev/null +++ b/branchements/03.tex @@ -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} + diff --git a/branchements/04.tex b/branchements/04.tex new file mode 100644 index 0000000..629e40c --- /dev/null +++ b/branchements/04.tex @@ -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} + diff --git a/branchements/05.tex b/branchements/05.tex new file mode 100644 index 0000000..d100031 --- /dev/null +++ b/branchements/05.tex @@ -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} + diff --git a/branchements/06.tex b/branchements/06.tex new file mode 100644 index 0000000..69dc3aa --- /dev/null +++ b/branchements/06.tex @@ -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} + diff --git a/branchements/07.tex b/branchements/07.tex new file mode 100644 index 0000000..3de5af1 --- /dev/null +++ b/branchements/07.tex @@ -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} + diff --git a/branchements/08.tex b/branchements/08.tex new file mode 100644 index 0000000..d38f2c8 --- /dev/null +++ b/branchements/08.tex @@ -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} + diff --git a/branchements/09.tex b/branchements/09.tex new file mode 100644 index 0000000..201d654 --- /dev/null +++ b/branchements/09.tex @@ -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} + diff --git a/branchements/10.tex b/branchements/10.tex new file mode 100644 index 0000000..8cc4cde --- /dev/null +++ b/branchements/10.tex @@ -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} + diff --git a/branchements/11.tex b/branchements/11.tex new file mode 100644 index 0000000..4c04d6f --- /dev/null +++ b/branchements/11.tex @@ -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} + diff --git a/branchements/12.tex b/branchements/12.tex new file mode 100644 index 0000000..49399d8 --- /dev/null +++ b/branchements/12.tex @@ -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} + diff --git a/branchements/13.tex b/branchements/13.tex new file mode 100644 index 0000000..b0e55e3 --- /dev/null +++ b/branchements/13.tex @@ -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} + diff --git a/branchements/14.tex b/branchements/14.tex new file mode 100644 index 0000000..2e0347e --- /dev/null +++ b/branchements/14.tex @@ -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} + diff --git a/branchements/15.tex b/branchements/15.tex new file mode 100644 index 0000000..062cedd --- /dev/null +++ b/branchements/15.tex @@ -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} + diff --git a/branchements/16.tex b/branchements/16.tex new file mode 100644 index 0000000..5d54cce --- /dev/null +++ b/branchements/16.tex @@ -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} + diff --git a/branchements/17.tex b/branchements/17.tex new file mode 100644 index 0000000..bcd1b17 --- /dev/null +++ b/branchements/17.tex @@ -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} + diff --git a/branchements/18.tex b/branchements/18.tex new file mode 100644 index 0000000..7b1c987 --- /dev/null +++ b/branchements/18.tex @@ -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} + diff --git a/branchements/19.tex b/branchements/19.tex new file mode 100644 index 0000000..6a34af4 --- /dev/null +++ b/branchements/19.tex @@ -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} + diff --git a/branchements/20.tex b/branchements/20.tex new file mode 100644 index 0000000..a2064b6 --- /dev/null +++ b/branchements/20.tex @@ -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} + diff --git a/branchements/21.tex b/branchements/21.tex new file mode 100644 index 0000000..a5c72f3 --- /dev/null +++ b/branchements/21.tex @@ -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} + diff --git a/branchements/22.tex b/branchements/22.tex new file mode 100644 index 0000000..d5ebb77 --- /dev/null +++ b/branchements/22.tex @@ -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} + diff --git a/branchements/23.tex b/branchements/23.tex new file mode 100644 index 0000000..74bd122 --- /dev/null +++ b/branchements/23.tex @@ -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} + diff --git a/branchements/24.tex b/branchements/24.tex new file mode 100644 index 0000000..6ed0d52 --- /dev/null +++ b/branchements/24.tex @@ -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} + diff --git a/branchements/25.tex b/branchements/25.tex new file mode 100644 index 0000000..aaecbe9 --- /dev/null +++ b/branchements/25.tex @@ -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} + diff --git a/branchements/26.tex b/branchements/26.tex new file mode 100644 index 0000000..1b64437 --- /dev/null +++ b/branchements/26.tex @@ -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} + diff --git a/branchements/27.tex b/branchements/27.tex new file mode 100644 index 0000000..73c83f1 --- /dev/null +++ b/branchements/27.tex @@ -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} + diff --git a/branchements/28.tex b/branchements/28.tex new file mode 100644 index 0000000..7fa09ac --- /dev/null +++ b/branchements/28.tex @@ -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} + diff --git a/branchements/29.tex b/branchements/29.tex new file mode 100644 index 0000000..eca92d6 --- /dev/null +++ b/branchements/29.tex @@ -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} + diff --git a/branchements/30.tex b/branchements/30.tex new file mode 100644 index 0000000..00b2f9c --- /dev/null +++ b/branchements/30.tex @@ -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} + diff --git a/branchements/31.tex b/branchements/31.tex new file mode 100644 index 0000000..d7aeba6 --- /dev/null +++ b/branchements/31.tex @@ -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} + diff --git a/branchements/32.tex b/branchements/32.tex new file mode 100644 index 0000000..d685171 --- /dev/null +++ b/branchements/32.tex @@ -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} + diff --git a/branchements/33.tex b/branchements/33.tex new file mode 100644 index 0000000..cc60278 --- /dev/null +++ b/branchements/33.tex @@ -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} + diff --git a/branchements/34.tex b/branchements/34.tex new file mode 100644 index 0000000..c86fe2c --- /dev/null +++ b/branchements/34.tex @@ -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} diff --git a/branchements/branchements.tex b/branchements/branchements.tex new file mode 100644 index 0000000..901566f --- /dev/null +++ b/branchements/branchements.tex @@ -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} diff --git a/generalites/01.tex b/generalites/01.tex new file mode 100644 index 0000000..e8a2e22 --- /dev/null +++ b/generalites/01.tex @@ -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} diff --git a/generalites/02.tex b/generalites/02.tex new file mode 100644 index 0000000..461c244 --- /dev/null +++ b/generalites/02.tex @@ -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} diff --git a/generalites/03.tex b/generalites/03.tex new file mode 100644 index 0000000..45dbcdc --- /dev/null +++ b/generalites/03.tex @@ -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} diff --git a/generalites/04.tex b/generalites/04.tex new file mode 100644 index 0000000..70c9cde --- /dev/null +++ b/generalites/04.tex @@ -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} + diff --git a/generalites/05.tex b/generalites/05.tex new file mode 100644 index 0000000..cc086e0 --- /dev/null +++ b/generalites/05.tex @@ -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} + diff --git a/generalites/06.tex b/generalites/06.tex new file mode 100644 index 0000000..8788234 --- /dev/null +++ b/generalites/06.tex @@ -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} + diff --git a/generalites/07.tex b/generalites/07.tex new file mode 100644 index 0000000..be54107 --- /dev/null +++ b/generalites/07.tex @@ -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} + diff --git a/generalites/08.tex b/generalites/08.tex new file mode 100644 index 0000000..ce4e239 --- /dev/null +++ b/generalites/08.tex @@ -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} + diff --git a/generalites/09.tex b/generalites/09.tex new file mode 100644 index 0000000..87c06d0 --- /dev/null +++ b/generalites/09.tex @@ -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} + diff --git a/generalites/10.tex b/generalites/10.tex new file mode 100644 index 0000000..6f970eb --- /dev/null +++ b/generalites/10.tex @@ -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} + diff --git a/generalites/11.tex b/generalites/11.tex new file mode 100644 index 0000000..c3117cb --- /dev/null +++ b/generalites/11.tex @@ -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} + diff --git a/generalites/12.tex b/generalites/12.tex new file mode 100644 index 0000000..299ff4b --- /dev/null +++ b/generalites/12.tex @@ -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} + diff --git a/generalites/generalites.tex b/generalites/generalites.tex new file mode 100644 index 0000000..81a960f --- /dev/null +++ b/generalites/generalites.tex @@ -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} diff --git a/operateurs/01.tex b/operateurs/01.tex new file mode 100644 index 0000000..336db22 --- /dev/null +++ b/operateurs/01.tex @@ -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} + diff --git a/operateurs/02.tex b/operateurs/02.tex new file mode 100644 index 0000000..2155de4 --- /dev/null +++ b/operateurs/02.tex @@ -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} + diff --git a/operateurs/03.tex b/operateurs/03.tex new file mode 100644 index 0000000..f85caad --- /dev/null +++ b/operateurs/03.tex @@ -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} + diff --git a/operateurs/04.tex b/operateurs/04.tex new file mode 100644 index 0000000..3101246 --- /dev/null +++ b/operateurs/04.tex @@ -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} + diff --git a/operateurs/05.tex b/operateurs/05.tex new file mode 100644 index 0000000..d80aaa1 --- /dev/null +++ b/operateurs/05.tex @@ -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 +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} + diff --git a/operateurs/06.tex b/operateurs/06.tex new file mode 100644 index 0000000..8932e49 --- /dev/null +++ b/operateurs/06.tex @@ -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} + diff --git a/operateurs/07.tex b/operateurs/07.tex new file mode 100644 index 0000000..baf5a8e --- /dev/null +++ b/operateurs/07.tex @@ -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} + diff --git a/operateurs/08.tex b/operateurs/08.tex new file mode 100644 index 0000000..ccea2ae --- /dev/null +++ b/operateurs/08.tex @@ -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} + diff --git a/operateurs/09.tex b/operateurs/09.tex new file mode 100644 index 0000000..490472c --- /dev/null +++ b/operateurs/09.tex @@ -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} + diff --git a/operateurs/10.tex b/operateurs/10.tex new file mode 100644 index 0000000..444f039 --- /dev/null +++ b/operateurs/10.tex @@ -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} + diff --git a/operateurs/11.tex b/operateurs/11.tex new file mode 100644 index 0000000..6f1ddcc --- /dev/null +++ b/operateurs/11.tex @@ -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} + diff --git a/operateurs/12-1.tex b/operateurs/12-1.tex new file mode 100644 index 0000000..77e410e --- /dev/null +++ b/operateurs/12-1.tex @@ -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} + diff --git a/operateurs/12.tex b/operateurs/12.tex new file mode 100644 index 0000000..c7dbf14 --- /dev/null +++ b/operateurs/12.tex @@ -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} + diff --git a/operateurs/13.tex b/operateurs/13.tex new file mode 100644 index 0000000..1e55ea1 --- /dev/null +++ b/operateurs/13.tex @@ -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} + diff --git a/operateurs/14.tex b/operateurs/14.tex new file mode 100644 index 0000000..4fa0c30 --- /dev/null +++ b/operateurs/14.tex @@ -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} + diff --git a/operateurs/15.tex b/operateurs/15.tex new file mode 100644 index 0000000..5ec660c --- /dev/null +++ b/operateurs/15.tex @@ -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} + diff --git a/operateurs/16.tex b/operateurs/16.tex new file mode 100644 index 0000000..c21d429 --- /dev/null +++ b/operateurs/16.tex @@ -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} + diff --git a/operateurs/17.tex b/operateurs/17.tex new file mode 100644 index 0000000..17ac068 --- /dev/null +++ b/operateurs/17.tex @@ -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} + diff --git a/operateurs/18.tex b/operateurs/18.tex new file mode 100644 index 0000000..73710bd --- /dev/null +++ b/operateurs/18.tex @@ -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} + diff --git a/operateurs/19.tex b/operateurs/19.tex new file mode 100644 index 0000000..70bf8af --- /dev/null +++ b/operateurs/19.tex @@ -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} + diff --git a/operateurs/20.tex b/operateurs/20.tex new file mode 100644 index 0000000..31b453b --- /dev/null +++ b/operateurs/20.tex @@ -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} + diff --git a/operateurs/21.tex b/operateurs/21.tex new file mode 100644 index 0000000..2740170 --- /dev/null +++ b/operateurs/21.tex @@ -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} + diff --git a/operateurs/22.tex b/operateurs/22.tex new file mode 100644 index 0000000..ae23254 --- /dev/null +++ b/operateurs/22.tex @@ -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 +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} + diff --git a/operateurs/23.tex b/operateurs/23.tex new file mode 100644 index 0000000..7476f6d --- /dev/null +++ b/operateurs/23.tex @@ -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 +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} + diff --git a/operateurs/24.tex b/operateurs/24.tex new file mode 100644 index 0000000..ed2d7e4 --- /dev/null +++ b/operateurs/24.tex @@ -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 +int a = 5; +bool c; +c = a < 7; // c vaut 1 (vrai)\end{verbatim} + \end{exampleblock} +\end{frame} + diff --git a/operateurs/25.tex b/operateurs/25.tex new file mode 100644 index 0000000..22aa3c2 --- /dev/null +++ b/operateurs/25.tex @@ -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 +int a = 5; +bool c; +c = a > 7; // c vaut 0 (faux)\end{verbatim} + \end{exampleblock} + +\end{frame} + diff --git a/operateurs/26.tex b/operateurs/26.tex new file mode 100644 index 0000000..4f1a58e --- /dev/null +++ b/operateurs/26.tex @@ -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 +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} + diff --git a/operateurs/27.tex b/operateurs/27.tex new file mode 100644 index 0000000..9fd9543 --- /dev/null +++ b/operateurs/27.tex @@ -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 +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} + diff --git a/operateurs/28.tex b/operateurs/28.tex new file mode 100644 index 0000000..6bf919c --- /dev/null +++ b/operateurs/28.tex @@ -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 +int a = 5, b = 8; +bool c = (a < 7) && (b > 10); // c vaut 0 (faux) + \end{verbatim} + \end{exampleblock} +\end{frame} + diff --git a/operateurs/29.tex b/operateurs/29.tex new file mode 100644 index 0000000..189502c --- /dev/null +++ b/operateurs/29.tex @@ -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 +int a = 5, b = 8; +bool c = (a < 7) || (b > 10); // c vaut 1 (vrai) + \end{verbatim} + \end{exampleblock} +\end{frame} + diff --git a/operateurs/30.tex b/operateurs/30.tex new file mode 100644 index 0000000..0fea15d --- /dev/null +++ b/operateurs/30.tex @@ -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} + diff --git a/operateurs/31.tex b/operateurs/31.tex new file mode 100644 index 0000000..30c0ec6 --- /dev/null +++ b/operateurs/31.tex @@ -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 +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} + diff --git a/operateurs/32.tex b/operateurs/32.tex new file mode 100644 index 0000000..ba57ca0 --- /dev/null +++ b/operateurs/32.tex @@ -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} + diff --git a/operateurs/33.tex b/operateurs/33.tex new file mode 100644 index 0000000..b452b22 --- /dev/null +++ b/operateurs/33.tex @@ -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|| 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} + diff --git a/operateurs/34.tex b/operateurs/34.tex new file mode 100644 index 0000000..5b262c6 --- /dev/null +++ b/operateurs/34.tex @@ -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} + diff --git a/operateurs/35.tex b/operateurs/35.tex new file mode 100644 index 0000000..53fee24 --- /dev/null +++ b/operateurs/35.tex @@ -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} + diff --git a/operateurs/operateurs.tex b/operateurs/operateurs.tex new file mode 100644 index 0000000..32ba23f --- /dev/null +++ b/operateurs/operateurs.tex @@ -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} diff --git a/pointeurs/._pointeurs.tex b/pointeurs/._pointeurs.tex new file mode 100644 index 0000000000000000000000000000000000000000..e00b3b00692573acdff4abf73d9558118b66f15b GIT binary patch literal 4096 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDJkFz{^v(m+1nBL)UWxe(WgkdV}fVxSlf z;207TWIgNTe~1o-3LMHtg-1hRGz3ONU^E0qLtr!nMnhmU1V%$(Gz3ONU^E0qLx8Fw zzz8%Aguy^ABqOs}p(wRDzqBYhRUs|EC|e;juOv0EBr`uRF(;=|AtyDhL?J0BF)tg~ U7l!H@(iE!y;a-tpko*5100H|T>;M1& literal 0 HcmV?d00001 diff --git a/pointeurs/01.tex b/pointeurs/01.tex new file mode 100644 index 0000000..03736b1 --- /dev/null +++ b/pointeurs/01.tex @@ -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} + diff --git a/pointeurs/02.tex b/pointeurs/02.tex new file mode 100644 index 0000000..f9ecd65 --- /dev/null +++ b/pointeurs/02.tex @@ -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} + diff --git a/pointeurs/03.tex b/pointeurs/03.tex new file mode 100644 index 0000000..1bfaaae --- /dev/null +++ b/pointeurs/03.tex @@ -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} + diff --git a/pointeurs/04.tex b/pointeurs/04.tex new file mode 100644 index 0000000..f595004 --- /dev/null +++ b/pointeurs/04.tex @@ -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} + diff --git a/pointeurs/05.tex b/pointeurs/05.tex new file mode 100644 index 0000000..5e7df19 --- /dev/null +++ b/pointeurs/05.tex @@ -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} + diff --git a/pointeurs/06.tex b/pointeurs/06.tex new file mode 100644 index 0000000..01791ed --- /dev/null +++ b/pointeurs/06.tex @@ -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} + diff --git a/pointeurs/07.tex b/pointeurs/07.tex new file mode 100644 index 0000000..a93c7c9 --- /dev/null +++ b/pointeurs/07.tex @@ -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} + diff --git a/pointeurs/08.tex b/pointeurs/08.tex new file mode 100644 index 0000000..98f75e1 --- /dev/null +++ b/pointeurs/08.tex @@ -0,0 +1,19 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: L'opérateur *~II} + + \begin{exampleblock}{Déréférencements de pointeurs} + \begin{verbatim} +int a = 5, *b, *c, d, **e; +b = &a; //&a renvoie un int * +c = b; // b et c pointent vers a +d = *b; // d reçoit la valeur pointée par b : la valeur de a +a = 2; // a vaut 2, d vaut toujours 5 +*b = 3; // a vaut 3, d vaut toujours 5 +d = 1; // a vaut toujours 3, d vaut 1 +c = NULL; // b pointe toujours sur a, c vaut NULL +e = &c; // &c renvoie un int ** +*e = &d; // c reçoit l'adresse de d (int *)\end{verbatim} + \end{exampleblock} +\end{frame} + diff --git a/pointeurs/09.tex b/pointeurs/09.tex new file mode 100644 index 0000000..de6b52f --- /dev/null +++ b/pointeurs/09.tex @@ -0,0 +1,19 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: L'opérateur ->~I} + + Lorsqu'on souhaite accéder à un membre d'une structure ou d'une union pointée, il est possible d'utiliser les opérateurs * et . comme suit. + \begin{exampleblock}{Accès aux membres d'une structure pointée} + \begin{verbatim} +short anneeActuelle = 2010; +struct Date { + unsigned char jour; + unsigned char mois; + short * annee; +}; +struct Data maDate = {10, 11, NULL}, *pMaDate; +pMaDate = &maDate; +(*pMaDate).jour = 11;\end{verbatim} + \end{exampleblock} +\end{frame} + diff --git a/pointeurs/10.tex b/pointeurs/10.tex new file mode 100644 index 0000000..cf44494 --- /dev/null +++ b/pointeurs/10.tex @@ -0,0 +1,20 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: L'opérateur ->~II} + + Afin d'alléger l'écriture, il est possible d'utiliser l'opérateur \texttt{->} sur un pointeur de structure ou d'union pour accéder au membre qui suit la flèche. + \vspace{0.3cm} + \par + Autrement dit, l'opérateur \texttt{->} déréférence son opérande gauche, de type structure ou union, et accède au membre nommé comme opérande droit. + \begin{block}{Syntaxe générale de l'opérateur ->} + \begin{verbatim} +pointeurSurStructureOuUnion->membre\end{verbatim} + \end{block} + \begin{exampleblock}{Exemple d'utilisation de l'opérateur ->} + \begin{verbatim} +struct Date maDate = {11, 11, NULL}; +struct * pMaDate = &maDate; +pMaDate->jour += 1; //équivalent à (*pMaDate).jour += 1\end{verbatim} + \end{exampleblock} +\end{frame} + diff --git a/pointeurs/11.tex b/pointeurs/11.tex new file mode 100644 index 0000000..f338a9d --- /dev/null +++ b/pointeurs/11.tex @@ -0,0 +1,22 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: L'opérateur ->~III} + + \begin{alertblock}{L'opérateur -> et les membres pointeurs} + L'opérateur \texttt{->} ne permet pas de déréférencer les membres pointeurs. + \vspace{0.3cm} + \par + Pour cela, il faut déréférencer l'expression retournant + la valeur du pointeur-membre. + \end{alertblock} + \begin{exampleblock}{Déréférencement d'un pointeur membre} + \begin{verbatim} +int iExemple; +struct Exemple { + int * membre; +} e; +e.membre = &iExemple; +*(e.membre) = 10;\end{verbatim} + \end{exampleblock} +\end{frame} + diff --git a/pointeurs/12.tex b/pointeurs/12.tex new file mode 100644 index 0000000..f7de792 --- /dev/null +++ b/pointeurs/12.tex @@ -0,0 +1,23 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~I} + + Les pointeurs sont de simples variables de type numérique contenant une adresse mémoire. On peut recopier leur valeur de la même manière + qu'on peut copier n'importe quel type primitif. + {\small\begin{exampleblock}{Recopie d'un pointeur} + \begin{verbatim} +int a = 5, *b, *c; +b = &a; +c = b; //recopie de pointeurs\end{verbatim} + \end{exampleblock}} + \par + De la même manière, quand on affecte une instance de structure, tous ses membres sont recopiés~! + {\small\begin{exampleblock}{Recopie des membres d'une structure} + \begin{verbatim} +struct Date maDate = {11, 11, NULL}, maDate2; +maDate2 = maDate; +maDate.jour = 12; //ne modifie pas la valeur dans maDate2.jour +maDate2.jour // expression valant 11\end{verbatim} + \end{exampleblock}} +\end{frame} + diff --git a/pointeurs/13.tex b/pointeurs/13.tex new file mode 100644 index 0000000..84cb6ce --- /dev/null +++ b/pointeurs/13.tex @@ -0,0 +1,14 @@ +\begin{frame}%[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~II} + + Un problème se pose cependant quand on recopie une structure ayant des membres de type pointeur. + \vspace{0.5cm} + \par + Les pointeurs sont bien recopiés\ldots C'est-à-dire que la valeur qu'ils contiennent est recopiée~: l'adresse mémoire vers laquelle ils + pointent~! + \par + Ainsi, si les membres non-pointeurs deviennent indépendants de leur original après recopie, les membres-pointeurs continuent de + pointer vers la même zone mémoire~! +\end{frame} + diff --git a/pointeurs/14.tex b/pointeurs/14.tex new file mode 100644 index 0000000..a34ae93 --- /dev/null +++ b/pointeurs/14.tex @@ -0,0 +1,22 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~III} + + {\small\begin{exampleblock}{Recopie de pointeur} + \begin{verbatim} +int year; +struct Date maDate = {11, 11, &year}, maDate2; + +maDate2 = maDate; //recopie des structures + +maDate.jour = 12; //maDate.jour vaut 12, maDate2.jour vaut 11 + +year = 2012; //*(maDate.annee) vaut 2012, + //*(maDate2.annee) vaut 2012 + +*(maDate.annee) = 2010; //*(maDate2.annee) vaut aussi 2010 + +maDate.annee = NULL; //maDate2.annee pointe toujours vers year\end{verbatim} + \end{exampleblock}} +\end{frame} + diff --git a/pointeurs/15.tex b/pointeurs/15.tex new file mode 100644 index 0000000..d7ca4c2 --- /dev/null +++ b/pointeurs/15.tex @@ -0,0 +1,12 @@ +\begin{frame}%[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~I} + + Nous avons déjà vu que les paramètres d'une fonction sont initialisés par recopie de la valeur de l'argument ayant la même ordonnée + (e.g.le deuxième argument voit sa valeur \textbf{recopiée} dans le deuxième paramètre d'une fonction). + \vspace{0.5cm} + \par + Ce mode de passage de paramètre s'appelle \textit{le passage de paramètre par valeur} et est \textbf{le seul} mode de passage + d'argument disponible en C~! +\end{frame} + diff --git a/pointeurs/16.tex b/pointeurs/16.tex new file mode 100644 index 0000000..e89152a --- /dev/null +++ b/pointeurs/16.tex @@ -0,0 +1,22 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~II} + + \begin{exampleblock}{Passage de paramètre par valeur} + \begin{verbatim} +int addTwo(int value) { + value += 2; + return value; +} +int main() { + int val = 1, returnedValue; + returnedValue = addTwo(val); + return returnedValue; +}\end{verbatim} + \end{exampleblock} + \vspace{0.3cm} + \par + Dans cet exemple, la valeur de \texttt{val} est recopiée dans la variable locale à la fonction \texttt{addTwo} \texttt{value}. + L'addition dans \texttt{addTwo} ne modifie pas la valeur de \texttt{val}, mais uniquement celle de \texttt{value}. +\end{frame} + diff --git a/pointeurs/17.tex b/pointeurs/17.tex new file mode 100644 index 0000000..543b900 --- /dev/null +++ b/pointeurs/17.tex @@ -0,0 +1,15 @@ +\begin{frame}%[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~III} + + Nous avons également vu qu'une fonction ne peut renvoyer qu'une seule valeur, du type précisé dans son prototype. Jusqu'à présent, + si nous voulions renvoyer plusieurs valeurs, il nous fallait déclarer un type structuré, et le renvoyer. + \vspace{0.5cm} + \par + Les pointeurs peuvent aider à renvoyer plusieurs valeurs. + \vspace{0.3cm} + \par + Leur valeur (une adresse mémoire) sera bien recopiée, mais ils continueront de pointer vers une adresse mémoire, dont on pourra modifier + le contenu grâce à l'opérateur de déréférencement~! +\end{frame} + diff --git a/pointeurs/18.tex b/pointeurs/18.tex new file mode 100644 index 0000000..ded998d --- /dev/null +++ b/pointeurs/18.tex @@ -0,0 +1,23 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~IV} + + \begin{exampleblock}{Passage de pointeurs à une fonction} + \begin{verbatim} +void add(int leftOp, int rightOp, int * result) { + *result = leftOp + rightOp; +} + +int main() { + int returnedValue; + add(5, 2, &returnedValue); + return returnedValue; +}\end{verbatim} + \end{exampleblock} + \vspace{0.3cm} + \par + L'adresse de la variable \texttt{returnedValue} est passée à la fonction \texttt{add}. Celle-ci peut alors accéder à la zone mémoire de + la variable \texttt{returnedValue} par déférencement du pointeur \texttt{result} qui a été initialisé par recopie du troisième argument + de l'appel à la fonction. +\end{frame} + diff --git a/pointeurs/19.tex b/pointeurs/19.tex new file mode 100644 index 0000000..b20884b --- /dev/null +++ b/pointeurs/19.tex @@ -0,0 +1,21 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~V} + + \begin{alertblock}{Portée des variables et retour de fonction} + Bien qu'une fonction puisse retourner tout type y compris des pointeurs, il n'est pas possible de renvoyer un pointeur sur une + variable locale qu'on s'apprête à quitter. Le code suivant est \textbf{INVALIDE}~: + \begin{verbatim} +int * example() { + int val = 5; + return &val; +}\end{verbatim} + Le code suivant est également \textbf{INVALIDE}~: + \begin{verbatim} +int * exemple(int value) { + value += 2; + return &value; +}\end{verbatim} + \end{alertblock} +\end{frame} + diff --git a/pointeurs/20.tex b/pointeurs/20.tex new file mode 100644 index 0000000..82288e3 --- /dev/null +++ b/pointeurs/20.tex @@ -0,0 +1,12 @@ +\begin{frame}%[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~VI} + + Une fonction peut cependant renvoyer un pointeur de manière légale en renvoyant une adresse mémoire qui reste toujours valide, + même après la fin de la fonction. + \vspace{0.5cm} + \par + Ce genre d'adresses mémoire peut être réservé à l'aide de fonctions telles que \texttt{malloc}, \texttt{realloc} et \texttt{calloc}, + toutes trois disponibles dans la bibliothèque $<$stdlib.h$>$. +\end{frame} + diff --git a/pointeurs/21.tex b/pointeurs/21.tex new file mode 100644 index 0000000..502cc83 --- /dev/null +++ b/pointeurs/21.tex @@ -0,0 +1,17 @@ +\begin{frame}%[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Qu'est ce qu'un tableau ?} + + Un tableau est une zone mémoire composée de un ou plusieurs espaces mémoire contigües, chacun de la taille du type de données du tableau. + \vspace{0.3cm} + \par + Ils peuvent être locaux à une fonction, globaux, statiques, alloués statiquement (taille fixée) ou dynamiquement. + \vspace{0.3cm} + \par + En C89, la taille des tableaux doit être une \textbf{constante} numérique entière, ou ils doivent être alloués dynamiquement avec + une fonction de la famille \texttt{malloc} ou la fonction \texttt{alloca} (spécifique à GLIBC). + \vspace{0.3cm} + \par + Depuis C99 (et en C++), une expression peut être utilisée pour déclarer la taille d'un tableau. +\end{frame} + diff --git a/pointeurs/22.tex b/pointeurs/22.tex new file mode 100644 index 0000000..ddfb9da --- /dev/null +++ b/pointeurs/22.tex @@ -0,0 +1,22 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: L'opérateur [ ]~I} + + Les tableaux de taille statique sont déclarés avec l'opérateur ``crochets'' \texttt{[]}. + \vspace{0.3cm} + \begin{exampleblock}{Déclaration simple d'un tableau} + \begin{verbatim} +int tableauDEntiers[5]; //alloue un tableau de 5 int\end{verbatim} + \end{exampleblock} + \begin{exampleblock}{Utilisation d'une expression pour déclarer un tableau} + \begin{verbatim} +bool exemple(size_t taille) { + if(taille > SIZE_MAX - 2) { + return false; + } + int tableauDEntier[taille + 2]; + // ... +}\end{verbatim} + \end{exampleblock} +\end{frame} + diff --git a/pointeurs/23.tex b/pointeurs/23.tex new file mode 100644 index 0000000..82c5a65 --- /dev/null +++ b/pointeurs/23.tex @@ -0,0 +1,20 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: L'opérateur [ ]~II} + + Il est possible d'allouer des tableaux à plusieurs dimensions en chainant plusieurs opérateurs crochets. + \vspace{0.3cm} + \par + Les deux dimensions n'ont pas besoin d'être identiques. En revanche, seules des matrices peuvent être ainsi déclarées (même nombre + de ``lignes'' dans les ``colonnes''). + \begin{exampleblock}{Déclaration d'un tableau à 2 dimensions} + \begin{verbatim} +int table[5][3];\end{verbatim} + \end{exampleblock} + Ce tableau a 5 ``colonnes'' de 3 ``lignes''. + \vspace{0.3cm} + \par + La notion de ``colonnes'' et de ``lignes'' est une simple vue, le tableau étant aplati en + mémoire à une seule dimension. +\end{frame} + diff --git a/pointeurs/24.tex b/pointeurs/24.tex new file mode 100644 index 0000000..b243492 --- /dev/null +++ b/pointeurs/24.tex @@ -0,0 +1,15 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: L'opérateur [ ]~III} + + Il est possible d'initialiser un tableau à la déclaration à l'aide d'accolades. + \vspace{0.5cm} + \par + Comme pour les structures, ce genre d'affectation n'est possible qu'au moment de la déclaration~! + \vspace{0.5cm} + \begin{exampleblock}{Initialisation d'un tableau à la déclaration} + \begin{verbatim} +int tableau[3] = {1, 2, 3};\end{verbatim} + \end{exampleblock} +\end{frame} + diff --git a/pointeurs/25.tex b/pointeurs/25.tex new file mode 100644 index 0000000..8d36a0a --- /dev/null +++ b/pointeurs/25.tex @@ -0,0 +1,21 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: L'opérateur [ ]~IV} + + Lors de la déclaration, si le tableau est initialisé, il est possible de ne pas préciser de dimension pour la dernière paire de + crochets. + \vspace{0.5cm} + \par + Dans ce cas, le tableau contient un nombre de cases égal aux nombres d'éléments dans l'initialisation. + \vspace{0.5cm} + \begin{exampleblock}{Initialisation d'un tableau de 4 cases sans dimension explicite} + \begin{verbatim} +int tableau[] = {1, 2, 3, 4};\end{verbatim} + \end{exampleblock} + + \begin{exampleblock}{Déclaration d'un tableau multi-dimension avec initialisation} + \begin{verbatim} +int tableau[2][3] = { {1, 2, 3}, {4, 5, 6} };\end{verbatim} + \end{exampleblock} +\end{frame} + diff --git a/pointeurs/27.tex b/pointeurs/27.tex new file mode 100644 index 0000000..95b23fc --- /dev/null +++ b/pointeurs/27.tex @@ -0,0 +1,20 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: L'opérateur [ ]~V} + + Si les accolades ne contiennent pas autant d'éléments que la dimension précisée entre ``crochets'', les éléments restants sont + initialisés à 0. + \vspace{0.5cm} + \begin{exampleblock}{Initialisation des élements restants d'un tableau à 0} + \begin{verbatim} +int tableau[5] = {1, 2}; +//équivalent à +int tableau[5] = {1, 2, 0, 0, 0};\end{verbatim} + \end{exampleblock} + \vspace{0.5cm} + \begin{exampleblock}{Astuce pour initialiser tous les éléments d'un tableau à 0} + \begin{verbatim} +int tableau[15] = {0};\end{verbatim} + \end{exampleblock} +\end{frame} + diff --git a/pointeurs/28.tex b/pointeurs/28.tex new file mode 100644 index 0000000..9f24a2c --- /dev/null +++ b/pointeurs/28.tex @@ -0,0 +1,19 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: L'opérateur [ ]~VI} + + Lors de l'initialisation, une syntaxe permet de n'initialiser que certains éléments, les autres valant 0. + \vspace{0.3cm} + \par + Pour cela, on place entre crochet le numéro de l'élément à initialiser et on lui affecte la valeur désirée. + \vspace{0.3cm} + \par + En C, \textbf{les indices des tableaux commencent à 0}. + \begin{exampleblock}{Initialisation partielle avec indice} + \begin{verbatim} +int tableau[5] = { [2] = 1, [4] = 2 }; +//équivalent à : +int tableau[5] = {0, 0, 1, 0, 2 };\end{verbatim} + \end{exampleblock} +\end{frame} + diff --git a/pointeurs/29.tex b/pointeurs/29.tex new file mode 100644 index 0000000..549311a --- /dev/null +++ b/pointeurs/29.tex @@ -0,0 +1,15 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: L'opérateur [ ]~VII} + + La syntaxe précédente combinée aux énumérations permet une très élégante syntaxe. + \vspace{0.5cm} + \begin{exampleblock}{Tableau, initialisation et énumérations} + \begin{verbatim} +enum Fruits { POMME, FRAISE, ORANGE }; +int tableau[3] = { [POMME] = 10, + [FRAISE] = 23, + [ORANGE] = 5 };\end{verbatim} + \end{exampleblock} +\end{frame} + diff --git a/pointeurs/30.tex b/pointeurs/30.tex new file mode 100644 index 0000000..38ef18c --- /dev/null +++ b/pointeurs/30.tex @@ -0,0 +1,19 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: L'opérateur [ ]~VIII} + + \begin{exampleblock}{Initialisation partielle d'un tableau avec indice} + \begin{verbatim} +int tableau[5] = { [2] = 4, 3, 4}; +//équivalent à +int tableau[5] = {0, 0, 4, 3, 4};\end{verbatim} + \end{exampleblock} + \begin{alertblock}{Danger de l'initialisation avec ``crochets''} + La syntaxe d'initialisation avec crochets est dangereuse (source d'erreur) si elle est mixée avec un tableau dont la taille n'est pas + fixée par une expression. Dans ce cas, la taille du tableau est équivalente à l'indice le plus élevé + 1. + \begin{verbatim}int tableau[] = { [4] = 1 }; +//équivalent à +int tableau[5] = {0, 0, 0, 0, 1};\end{verbatim} + \end{alertblock} +\end{frame} + diff --git a/pointeurs/31.tex b/pointeurs/31.tex new file mode 100644 index 0000000..5a9daf6 --- /dev/null +++ b/pointeurs/31.tex @@ -0,0 +1,16 @@ +\begin{frame}%[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: L'opérateur [ ]~IX} + + L'opérateur ``crochets'' permet également d'accéder aux cases d'un tableau, après la déclaration. Pour cela, on utilise l'identificateur + du tableau suivi d'une paire de crochet contenant une expression entière. Le résultat de l'expression indique l'indice du tableau qui + va être retourné. + \vspace{0.5cm} + \par + Les indices d'un tableau, en C, commencent à 0. Ainsi pour un tableau de 4 cases, les indices valides sont 0, 1, 2 et 3 ! + \vspace{0.5cm} + \par + 4 \textbf{N}'est alors \textbf{PAS} un indice valide ! Accéder à un indice invalide ne provoque pas toujours un crash de l'application, + mais souvent des résultats imprévisibles. Il s'agit d'une erreur importante de programmation. +\end{frame} + diff --git a/pointeurs/32.tex b/pointeurs/32.tex new file mode 100644 index 0000000..233da07 --- /dev/null +++ b/pointeurs/32.tex @@ -0,0 +1,19 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: L'opérateur [ ]~X} + + \begin{exampleblock}{Accès aux éléments d'un tableau} + \begin{verbatim} +int i, tableau[5] = {5, 3, 4, 2, 1}; +for(i = 0 ; i < 5 ; i++) { + afficher( tableau[i] ); +}\end{verbatim} + \end{exampleblock} + \vspace{0.5cm} + \begin{exampleblock}{Accès à un tableau à multiples dimensions} + \begin{verbatim} +int tableau[5][3]; +tableau[1][2] = 4;\end{verbatim} + \end{exampleblock} +\end{frame} + diff --git a/pointeurs/33.tex b/pointeurs/33.tex new file mode 100644 index 0000000..9f14e61 --- /dev/null +++ b/pointeurs/33.tex @@ -0,0 +1,20 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: L'opérateur sizeof~I} + + L'opérateur sizeof permet de retourner la taille d'un type de données. La taille renvoyée est exprimée en octets. + \vspace{0.3cm} + \begin{exampleblock}{Utilisation de l'opérateur sizeof} + \begin{verbatim} +sizeof int +// ou +sizeof(int)\end{verbatim} + \end{exampleblock} + \par + Sur un type complexe (structures, tableaux), l'opérateur sizeof prend tout son sens car la taille n'est pas forcément facilement calculable (notamment pour les structures à cause de l'alignement mémoire). + \vspace{0.3cm} + \par + Sur un tableau de taille statique déclaré localement à la fonction en cours, ou globalement, l'opérateur sizeof renvoie la + dimension du tableau multipliée par la taille des éléments de ce tableau. +\end{frame} + diff --git a/pointeurs/34.tex b/pointeurs/34.tex new file mode 100644 index 0000000..27be1b3 --- /dev/null +++ b/pointeurs/34.tex @@ -0,0 +1,13 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: L'opérateur sizeof~II} + + Pour connaitre le nombre d'éléments maximum d'un tableau, il est donc possible d'utiliser l'expression suivante~: + \vspace{0.5cm} + \begin{exampleblock}{Calcul de la dimension d'un tableau} + \begin{verbatim} +int tableau[] = { 1, 2, 3, 4, 5 }; +size_t tailleDuTableau = sizeof(tableau) / sizeof(int);\end{verbatim} + \end{exampleblock} +\end{frame} + diff --git a/pointeurs/35.tex b/pointeurs/35.tex new file mode 100644 index 0000000..75514fa --- /dev/null +++ b/pointeurs/35.tex @@ -0,0 +1,22 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Les chaines de caractères} + + En C, une chaine de caractères est un tableau de \texttt{char} dont le dernier caractère est la valeur 0 (ou le caractère '\verb|\|0'). + \vspace{0.3cm} + \par + Implicitement, cela signifie qu'il est nécessaire de prévoir une case de tableau supplémentaire pour le stockage de ce caractère nul. + \vspace{0.5cm} + \par + Une chaine de caractères constante littérale est terminée implicitement par un caractère nul. + \begin{exampleblock}{Initialisation d'une chaine de caractères} + \begin{verbatim} +char chaine[] = {'Y', 'O', 'U', 'P', 'I','\0' }; +char chaine2[] = {'Y', 'O', 'U', 'P', 'I', 0 }; +char chaine3[] = "Yeah"; +chaine3[2] = 'p'; +chaine3[3] = '\0'; // chaine3 vaut "Yep" +chaine3[1] = '\0'; // chaine3 vaut "Y"\end{verbatim} + \end{exampleblock} +\end{frame} + diff --git a/pointeurs/36.tex b/pointeurs/36.tex new file mode 100644 index 0000000..7f5e0b7 --- /dev/null +++ b/pointeurs/36.tex @@ -0,0 +1,19 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Les tableaux et les fonctions~I} + + Un tableau est une forme de pointeur. Si l'identificateur d'un tableau est utilisé sans l'opérateur crochets, alors l'adresse du premier + élément du tableau est retournée. + \vspace{0.3cm} + \par + De ce fait, on ne peut passer à une fonction qu'un élément du tableau (sa valeur), ou un pointeur (vers l'un des éléments du tableau). + \vspace{0.3cm} + \begin{exampleblock}{Un tableau en argument, un pointeur en paramètre} + \begin{verbatim} +void exemple(int * tab); +//... +int tableau[4]; +exemple(tableau);\end{verbatim} + \end{exampleblock} +\end{frame} + diff --git a/pointeurs/37.tex b/pointeurs/37.tex new file mode 100644 index 0000000..84d87e5 --- /dev/null +++ b/pointeurs/37.tex @@ -0,0 +1,19 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Les tableaux et les fonctions~II} + + \begin{exampleblock}{Passage d'un tableau à une fonction} + \begin{verbatim} +int addTwo(int * tableau, size_t taille) { + for(size_t i = 0 ; i < taille ; i++) { + tableau[i] += 2; + } +} +int main() { + int myTab[5] = {1, 2, 3, 4, 5}; + addTwo(myTab, sizeof(myTab)/sizeof(int)); + return 0; +}\end{verbatim} + \end{exampleblock} +\end{frame} + diff --git a/pointeurs/38.tex b/pointeurs/38.tex new file mode 100644 index 0000000..886390a --- /dev/null +++ b/pointeurs/38.tex @@ -0,0 +1,17 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Les tableaux et les fonctions~III} + + Tout comme les pointeurs sur des variables locales, il n'est pas possible de faire renvoyer un tableau déclaré localement à une + fonction. C'est-à-dire que le mot clé \texttt{return} ne peut être suivi de l'identificateur seul d'un tableau (ce qui revient + à un pointeur). + \vspace{0.5cm} + \begin{exampleblock}{Une fonction ne peut renvoyer un tableau local} + \begin{verbatim} +int * exemple(){ + int tableau[] = { 1, 2, 3 }; + return tableau; // INVALIDE !!! +}\end{verbatim} + \end{exampleblock} +\end{frame} + diff --git a/pointeurs/39.tex b/pointeurs/39.tex new file mode 100644 index 0000000..3b3f06a --- /dev/null +++ b/pointeurs/39.tex @@ -0,0 +1,19 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Les tableaux et les fonctions~IV} + + En revanche, une fonction peut parfaitement renvoyer un élément d'un tableau, s'il ne s'agit pas d'un pointeur sur une variable locale à + cette fonction. + + \begin{exampleblock}{Retour d'un élément de tableau} + \begin{verbatim} +int exemple(int * tab, size_t taille) { + for(size_t i = 0 ; i < taille ; i++) { + if(tab[i] % 2 == 0) { + return tab[i]; + } + } +}\end{verbatim} + \end{exampleblock} +\end{frame} + diff --git a/pointeurs/40.tex b/pointeurs/40.tex new file mode 100644 index 0000000..e1129f4 --- /dev/null +++ b/pointeurs/40.tex @@ -0,0 +1,12 @@ +\begin{frame} + \frametitle{\secname} + \framesubtitle{\subsecname~: Les tableaux et la recopie~I} + + Pour recopier les valeurs d'un tableau dans un autre tableau, il est nécessaire d'utiliser une approche itérative consistant à recopier + un à un les éléments du premier tableau dans le second (éventuellement à l'aide de fonctions spécialisées\ldots). + \vspace{0.5cm} + \par + Pour se faire, une approche basique est l'utilisation d'une boucle. Il est très important de veiller à ce que le tableau de destination + soit suffisamment grand pour accueillir toutes les valeurs en entrée ! +\end{frame} + diff --git a/pointeurs/41.tex b/pointeurs/41.tex new file mode 100644 index 0000000..8e68477 --- /dev/null +++ b/pointeurs/41.tex @@ -0,0 +1,16 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Les tableaux et la recopie~II} + + \begin{exampleblock}{Recopie des éléments d'un tableau} + \begin{verbatim} +void exemple(int * tableau, size_t taille) { + int tab[taille]; + for(size_t i = 0 ; i < taille ; i++) { + tab[i] = tableau[i]; + } + // d'autres traitements... +}\end{verbatim} + \end{exampleblock} +\end{frame} + diff --git a/pointeurs/42.tex b/pointeurs/42.tex new file mode 100644 index 0000000..29e6512 --- /dev/null +++ b/pointeurs/42.tex @@ -0,0 +1,14 @@ +\begin{frame} + \frametitle{\secname} + \framesubtitle{\subsecname~: Les tableaux et la recopie~III} + + Il existe une exception au point précédent qui dit que la recopie doit être manuelle. + \vspace{0.5cm} + \par + Si un tableau (\textbf{un tableau de taille statique~! pas un pointeur~!}) est membre d'une structure, alors lorsque la structure est + recopiée, le tableau et ses valeurs le sont également~! + \par + Cette exception est valable aussi lors d'un passage de paramètre (le paramètre structuré reçoit une copie de la structure + dont une copie du tableau-membre). +\end{frame} + diff --git a/pointeurs/43.tex b/pointeurs/43.tex new file mode 100644 index 0000000..4658c2c --- /dev/null +++ b/pointeurs/43.tex @@ -0,0 +1,23 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Les tableaux et la recopie~IV} + + {\small\begin{exampleblock}{Recopie d'une structure} + \begin{verbatim} +struct table { char tab[50]; size_t nbElements; }; +void exemple{struct table tableau) { + //traitements... + tableau.tab[0] = 0; + tableau.nbElements = 0; +} // Changements perdus : passage de param par valeur ! + +int main() { + struct table tableau = { {1, 2, 3}, 3 }, tableau2; + exemple(tableau); + tableau2 = tableau; // tableau2 contient { {1, 2, 3}, 3 } + tableau2.tab[1] = 4; //tableau vaut toujours { {1, 2, 3}, 3 } + return 0; +}\end{verbatim} + \end{exampleblock}} +\end{frame} + diff --git a/pointeurs/44.tex b/pointeurs/44.tex new file mode 100644 index 0000000..6e0d959 --- /dev/null +++ b/pointeurs/44.tex @@ -0,0 +1,17 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~I} + + Plus tôt, nous avons utilisé l'opérateur ``crochets'' sur un pointeur, dans une fonction, suite au passage d'un tableau en paramètre. + \vspace{0.3cm} + \par + Cette syntaxe est valide car l'opérateur ``crochets'' n'est autre qu'un raccourci pour de l'arithmétique sur les pointeurs suivi d'un + déréférencement. + \begin{exampleblock}{Opérateur [ ] et arithmétique sur pointeurs} + \begin{verbatim} +tab[i] +// est équivalent à +*(tab + i)\end{verbatim} + \end{exampleblock} +\end{frame} + diff --git a/pointeurs/45.tex b/pointeurs/45.tex new file mode 100644 index 0000000..87f3695 --- /dev/null +++ b/pointeurs/45.tex @@ -0,0 +1,14 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~II} + + En arithmétique sur les pointeurs, il est important de noter qu'une addition de 1 au pointeur ne signifie pas nécessairement + ``l'adresse mémoire stockée dans le pointeur + 1''. + \par + En fait, incrémenter un pointeur revient à ajouter à l'adresse mémoire qu'il stocke \texttt{sizeof} du type de données de ce pointeur. + \vspace{0.3cm} + \par + Sur architecture x86, par exemple, si on incrémente un pointeur sur \texttt{int}, cela ajoute 4 à l'adresse mémoire stockée dans le + pointeur. +\end{frame} + diff --git a/pointeurs/46.tex b/pointeurs/46.tex new file mode 100644 index 0000000..8b3d1cf --- /dev/null +++ b/pointeurs/46.tex @@ -0,0 +1,28 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~III} + + {\small\begin{exampleblock}{Arithmétique binaire et équivalence~I} + \begin{verbatim} +int exemple(int * tableau) { + return tableau[1]; +}\end{verbatim} + \end{exampleblock} + + \begin{exampleblock}{Arithmétique binaire et équivalence~II} + \begin{verbatim} +int exemple(int * tableau) { + return *(tableau + 1); +}\end{verbatim} + \end{exampleblock} + + \begin{exampleblock}{Arithmétique binaire et équivalence~III} + \begin{verbatim} +int exemple(int * tableau) { + return * ((int *) (((unsigned long) tableau) + + (sizeof (int))));; +}\end{verbatim} + \end{exampleblock}} + +\end{frame} + diff --git a/pointeurs/47.tex b/pointeurs/47.tex new file mode 100644 index 0000000..0ed1dcf --- /dev/null +++ b/pointeurs/47.tex @@ -0,0 +1,17 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~IV} + + S'il est assez rare de voir la dernière forme présentée dans l'exemple précédent, il est fréquent de rencontrer des pointeurs incrémentés. + + \begin{exampleblock}{Exemple d'incrémentation de pointeurs} + \begin{verbatim} +//valable uniquement en ASCII et sur l'interval [a-z] +// préférer toupper de + +for(char * ptr = string ; *ptr != 0 ; ptr++) { + *ptr -= ('a' - 'A'); +}\end{verbatim} + \end{exampleblock} +\end{frame} + diff --git a/pointeurs/pointeurs.tex b/pointeurs/pointeurs.tex new file mode 100644 index 0000000..67d4198 --- /dev/null +++ b/pointeurs/pointeurs.tex @@ -0,0 +1,107 @@ +\subsection*{Les types de données} + +\input{pointeurs/01} + +\input{pointeurs/02} + +\input{pointeurs/03} + +\input{pointeurs/04} + +\subsection*{Les opérateurs sur les pointeurs} + +\input{pointeurs/05} + +\input{pointeurs/06} + +\input{pointeurs/07} + +\input{pointeurs/08} + +\input{pointeurs/09} + +\input{pointeurs/10} + +\input{pointeurs/11} + +\subsection*{Type structuré et pointeurs~: La recopie} + +\input{pointeurs/12} + +\input{pointeurs/13} + +\input{pointeurs/14} + +\subsection*{Les fonctions et les pointeurs} + +\input{pointeurs/15} + +\input{pointeurs/16} + +\input{pointeurs/17} + +\input{pointeurs/18} + +\input{pointeurs/19} + +\input{pointeurs/20} + +\subsection*{Les tableaux} + +\input{pointeurs/21} + +\input{pointeurs/22} + +\input{pointeurs/23} + +\input{pointeurs/24} + +\input{pointeurs/25} + +\input{pointeurs/27} + +\input{pointeurs/28} + +\input{pointeurs/29} + +\input{pointeurs/30} + +\input{pointeurs/31} + +\input{pointeurs/32} + +\input{pointeurs/33} + +\input{pointeurs/34} + +\input{pointeurs/35} + +\input{pointeurs/36} + +\input{pointeurs/37} + +\input{pointeurs/38} + +\input{pointeurs/39} + +\input{pointeurs/40} + +\input{pointeurs/41} + +\input{pointeurs/42} + +\input{pointeurs/43} + +\subsection*{Arithmétique sur les pointeurs} + +\input{pointeurs/44} + +\input{pointeurs/45} + +\input{pointeurs/46} + +\input{pointeurs/47} + +%type du pointeur qui définit le nombre d'octets lus en mémoire +% déclaration d'un tableau avec des lignes de tailles différentes + diff --git a/structure/01.tex b/structure/01.tex new file mode 100644 index 0000000..438605d --- /dev/null +++ b/structure/01.tex @@ -0,0 +1,19 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname} + \begin{exampleblock}{helloworld.c} + \begin{verbatim} +#include + +/** Function main + +Displays a fixed message on standard output +@returns int the status code : 0 = success +*/ +int main() { + puts( "Hello, World" ) ; /* This is a comment */ + return 0 ; +} + \end{verbatim} + \end{exampleblock} +\end{frame} diff --git a/structure/02.tex b/structure/02.tex new file mode 100644 index 0000000..5b18a41 --- /dev/null +++ b/structure/02.tex @@ -0,0 +1,13 @@ +\begin{frame} + \frametitle{\secname} + \framesubtitle{\subsecname} + + \par + En C, le code (les fonctions, les déclarations, tout) est contenu dans des \emph{fichiers \textbf{.c}}. Un programme est constitué d'\textbf{au moins} un fichier .c. + \vspace{0.5cm} + \par + Nous verrons plus tard qu'il est possible de stocker des déclarations et autres directives dans des \emph{fichiers .h} dans le but de les partager entre plusieurs \emph{fichiers \textbf{.c}}. + \vspace{0.5cm} + \par + Les fichiers .h portent cette extension car elle signifie ``headers files'', c'est-à-dire \emph{fichier d'entête}. +\end{frame} diff --git a/structure/03.tex b/structure/03.tex new file mode 100644 index 0000000..357c64a --- /dev/null +++ b/structure/03.tex @@ -0,0 +1,11 @@ +\begin{frame} + \frametitle{\secname} + \framesubtitle{\subsecname~I} + \par + Une fonction est un regroupement d'instructions sous un nom, effectuant une tâche plus ou moins complexe + (incluant l'appel à d'autres fonctions) avant de retourner ou non un résultat à la fonction appelante. + \vspace{0.5cm} + \par + Les fonctions peuvent recevoir des paramètres pouvant affecter son fonctionnement. +\end{frame} + diff --git a/structure/04.tex b/structure/04.tex new file mode 100644 index 0000000..e9da4c6 --- /dev/null +++ b/structure/04.tex @@ -0,0 +1,22 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~II} + + \begin{block}{Exemple de fonction générique} + {\small\begin{verbatim} +type_retour nom_fonction(type_param1 nom_param1, + type_param2 nom_param2, ...) { + instructions +} + \end{verbatim}} + \end{block} + ``type\_retour'' désigne le \emph{type de données renvoyées} (nombre, caractères, pointeurs, rien\ldots). + \begin{exampleblock}{Exemple de fonction simple} + \begin{verbatim} +long toto() { + instructions +} + \end{verbatim} + \end{exampleblock} +\end{frame} + diff --git a/structure/05.tex b/structure/05.tex new file mode 100644 index 0000000..3226820 --- /dev/null +++ b/structure/05.tex @@ -0,0 +1,21 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~III} + + \begin{exampleblock}{Exemple de fonction avec paramètres} + \begin{verbatim} +short toto(long titi, char tata) { + instructions +} + \end{verbatim} + \end{exampleblock} + + \begin{exampleblock}{Exemple de fonction avec nombre de paramètres variable} + \begin{verbatim} +short toto(long titi, char tata, ...) { + instructions +} + \end{verbatim} + \end{exampleblock} +\end{frame} + diff --git a/structure/06.tex b/structure/06.tex new file mode 100644 index 0000000..9d31d06 --- /dev/null +++ b/structure/06.tex @@ -0,0 +1,22 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~IV} + + \begin{exampleblock}{Exemple de fonction simple} + \begin{verbatim} +long toto() { + instructions +} \end{verbatim} + \end{exampleblock} + \par + \begin{block}{Vocabulaire} + L'emplacement réservé aux instructions dans une fonction est délimité par une paire d'accolades. + \par + Ces accolades forment ce qu'on appelle un \textbf{block}. + \end{block} + + \begin{alertblock}{Emplacement des instructions} + Les fonctions sont le \emph{seul} endroit pouvant contenir des instructions. En dehors des fonctions peuvent se tenir des déclarations, ou des directives pré-processeur. + \end{alertblock} +\end{frame} + diff --git a/structure/07.tex b/structure/07.tex new file mode 100644 index 0000000..7657fb7 --- /dev/null +++ b/structure/07.tex @@ -0,0 +1,26 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname} + + \begin{block}{Profil simple de la fonction main()} + \begin{verbatim} +int main() { + instructions +} + \end{verbatim} + \end{block} + + \par + \textbf{Tout programme contient une fonction }\verb|main()|\textbf{.} + \vspace{0.3cm} + \par + Cette fonction est le point d'entrée du programme~: + \textbf{l'exécution commence par cette fonction et se termine lorsque le code de cette fonction a été entièrement exécuté} (sauf interruption inopinée). + \vspace{0.3cm} + \par + Le type de retour de la fonction \verb|main()| est normalisé et \textbf{doit} être \verb|int|. + \vspace{0.3cm} + \par + {\small L'usage du type \verb|void| n'est donc pas correct.} +\end{frame} + diff --git a/structure/08.tex b/structure/08.tex new file mode 100644 index 0000000..cd20a0c --- /dev/null +++ b/structure/08.tex @@ -0,0 +1,18 @@ +\begin{frame} + \frametitle{\secname} + \framesubtitle{\subsecname~I} + \begin{block}{Vocabulaire} + \par + La \textbf{déclaration} d'une fonction est lorsqu'on fait apprendre au compilateur à quoi ressemble une fonction. + \vspace{0.3cm} + \par + Les informations identifiant une fonction sont son type de retour, son nom, son nombre de paramètres et leurs types. + \vspace{0.3cm} + \par + On appelle l'ensemble de ces informations le \emph{profil} ou le \emph{prototype} de la fonction. + \vspace{0.3cm} + \par + L'\textbf{implémentation} d'une fonction est lorsqu'on rappelle le prototype d'une fonction, et qu'on définit les actions qu'elle doit entreprendre (par une série d'instructions). + \end{block} +\end{frame} + diff --git a/structure/09.tex b/structure/09.tex new file mode 100644 index 0000000..35509e9 --- /dev/null +++ b/structure/09.tex @@ -0,0 +1,20 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~II} + + \begin{exampleblock}{Exemple de déclaration d'une fonction} + \begin{verbatim} +int toto(int a, long b); + \end{verbatim} + \end{exampleblock} + + \begin{exampleblock}{Exemple d'implémentation d'une fonction} + \begin{verbatim} +int toto(int a, long b) { + instructions +} + \end{verbatim} + \end{exampleblock} + +\end{frame} + diff --git a/structure/10.tex b/structure/10.tex new file mode 100644 index 0000000..43e35c7 --- /dev/null +++ b/structure/10.tex @@ -0,0 +1,16 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~III} + + \begin{block}{Vocabulaire} + \par + Pour une fonction, lors de sa déclaration et de son implémentation \verb|int toto(int a, int b) { }|, on appelle \verb|a| et \verb|b| des \emph{paramètres}. + \vspace{0.5cm} + \par + Lorsqu'on appelle cette fonction (\verb|toto(1, 2);|), les valeurs \verb|1| et \verb|2| sont affectées respectivement à \verb|a| et \verb|b|. + \vspace{0.5cm} + \par + Les valeurs données lors d'un appel de fonction, et qui sont affectées aux paramètres sont nommées \emph{arguments} (de la fonction). + \end{block} +\end{frame} + diff --git a/structure/11.tex b/structure/11.tex new file mode 100644 index 0000000..881dd5a --- /dev/null +++ b/structure/11.tex @@ -0,0 +1,18 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~IV} + + Dans notre exemple précédent nous appelions la fonction \verb|puts()| avec comme argument la chaine de caractères \verb|"Hello, World"|. + \begin{exampleblock}{helloworld.c (extrait)} + \begin{verbatim} +puts( "Hello, World" ) ; + \end{verbatim} + \end{exampleblock} + \vspace{0.5cm} + \par + La fonction \verb|puts()| ne fait pas parti du langage C. + \vspace{0.5cm} + \par + Elle définit dans une \emph{bibliothèque de fonctions} qu'il est nécessaire d'\emph{importer} (ou \emph{inclure}) dans le programme pour que \verb|puts()| soit reconnue. +\end{frame} + diff --git a/structure/12.tex b/structure/12.tex new file mode 100644 index 0000000..bbd58a7 --- /dev/null +++ b/structure/12.tex @@ -0,0 +1,14 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~V} + + \par + Cette inclusion est faite par la directive pré-processeur \verb|#include| qui inclut le fichier \verb|stdio.h| contenant la déclaration de la fonction \verb|puts|. + \vspace{0.5cm} + \begin{exampleblock}{helloworld.c (extrait)} + \begin{verbatim} +#include + \end{verbatim} + \end{exampleblock} +\end{frame} + diff --git a/structure/13.tex b/structure/13.tex new file mode 100644 index 0000000..77256b3 --- /dev/null +++ b/structure/13.tex @@ -0,0 +1,16 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~I} + + Une fonction retourne une valeur à la fonction appelante par l'intermédiaire du mot-clé \verb|return|. + \vspace{0.5cm} + \begin{block}{Retour d'une fonction} + \begin{verbatim} +type_retour nom_fonction() { + instructions + return expression; +} + \end{verbatim} + \end{block} +\end{frame} + diff --git a/structure/14.tex b/structure/14.tex new file mode 100644 index 0000000..77ea552 --- /dev/null +++ b/structure/14.tex @@ -0,0 +1,12 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~II} + + \par + La valeur de retour (qui peut être une expression calculée) \textbf{doit} être du type précisé dans le profil de la fonction. + \vspace{0.5cm} + \par + Si une fonction a comme type de retour \textbf{void}, alors la fonction prend fin lorsque l'exécution atteint + l'accolade fermante de la fonction, ou que l'on rencontre le mot-clé \verb|return| sans aucune expression le suivant. +\end{frame} + diff --git a/structure/15.tex b/structure/15.tex new file mode 100644 index 0000000..d95f073 --- /dev/null +++ b/structure/15.tex @@ -0,0 +1,13 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~III} + + Les fonctions ne peuvent retourner grâce au mot-clé \verb|return| qu'une seule valeur~: il n'est pas possible de faire suivre le mot-clé return de plusieurs expressions. + \vspace{0.5cm} + \par + Le type retourné peut cependant être un type composé (structures, \ldots). + \vspace{0.5cm} + \par + Si plusieurs valeurs doivent être renvoyées, l'usage de pointeurs (que nous verrons plus loin dans le cours) est possible. +\end{frame} + diff --git a/structure/16.tex b/structure/16.tex new file mode 100644 index 0000000..b975372 --- /dev/null +++ b/structure/16.tex @@ -0,0 +1,22 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~IV} + + \begin{alertblock}{Sortie immédiate avec return} + \par + Le mot-clé return cause la sortie \textbf{immédiate} de la fonction en cours d'exécution. + \par + Toutes les instructions du même flux d'exécution (c.f. branchements conditionnels) suivant le \verb|return| sont ignorées. + \end{alertblock} + Ainsi avec le code suivant, l'appel à \verb|puts()| ne sera jamais exécuté. + \begin{block}{\texttt{puts()} ignoré} + \begin{verbatim} +int toto() { + return 0; + puts("Hello"); +} \end{verbatim} + \end{block} + \par + Plusieurs \verb|return| peuvent être utilisés dans une même fonction avec les branchements conditionnels. +\end{frame} + diff --git a/structure/17.tex b/structure/17.tex new file mode 100644 index 0000000..dea534d --- /dev/null +++ b/structure/17.tex @@ -0,0 +1,19 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~V} + + \par + Le prototype de la fonction \verb|main()| précise que le type de retour est \verb|int| (c'est-à-dire un nombre entier). + \par + On retrouve dans notre exemple ``helloworld'' la ligne suivante~: + \begin{exampleblock}{helloworld.c} + \begin{verbatim} + return 0 ; + \end{verbatim} + \end{exampleblock} + \par + Par convention, la fonction \verb|main()| renvoie 0 si l'exécution s'est terminée avec succès, ou une valeur non-nulle si l'exécution a rencontré un échec. + \par + La bibliothèque \verb|| définit également deux constantes \verb|EXIT_SUCCESS| et \verb|EXIT_FAILURE| qui peuvent être utilisées comme valeur de retour de \verb|main()|. +\end{frame} + diff --git a/structure/18.tex b/structure/18.tex new file mode 100644 index 0000000..261347a --- /dev/null +++ b/structure/18.tex @@ -0,0 +1,21 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname} + + En C, chaque instructions et déclarations sont séparées de la suivante par un \textbf{caractère de fin d'instruction}. + \par + Ce caractère est en général le \textbf{point-virgule}. + \par + Dans certains cas, la \textbf{virgule} peut également être un caractère de fin d'instruction, mais elle n'est que très rarement utilisée. + \begin{exampleblock}{helloworld.c} + \begin{verbatim} +#include + +int main() { + puts( "Hello, World" ) ; + return 0 ; +} \end{verbatim} + \end{exampleblock} + On remarquera que les directives préprocesseur ne se terminent pas par un caractère de fin d'instruction. +\end{frame} + diff --git a/structure/19.tex b/structure/19.tex new file mode 100644 index 0000000..09b375b --- /dev/null +++ b/structure/19.tex @@ -0,0 +1,12 @@ +\begin{frame} + \frametitle{\secname} + \framesubtitle{\subsecname~I} + + Il est possible de placer des commentaires dans les fichiers source à n'importe quel endroit, du moment qu'ils ne se trouvent pas au beau milieu d'un identifiant ou d'un mot-clé. + \par + Si les commentaires contiennent du code, ce dernier ne sera pas pris en compte. En fait, les commentaires sont retirés du code avant l'étape de la compilation, par le préprocesseur. + \vspace{0.5cm} + \par + \textbf{Les commentaires ont pour fonction principale de rendre le code plus lisible} en explicitant des opérations complexes en langage naturel pour un humain. +\end{frame} + diff --git a/structure/20.tex b/structure/20.tex new file mode 100644 index 0000000..0fccc91 --- /dev/null +++ b/structure/20.tex @@ -0,0 +1,12 @@ +\begin{frame} + \frametitle{\secname} + \framesubtitle{\subsecname~II} + + \par + L'anglais est conseillé afin que le code puisse être relu par n'importe quel développeur, quelque soit sa langue maternelle. + \vspace{0.5cm} + \par + Un bon commentaire ne paraphrase pas le code, mais explicite des valeurs, des calculs, ou des opérations singulières, ou + résume une série d'instruction (l'intention du développeur en les codant). +\end{frame} + diff --git a/structure/21.tex b/structure/21.tex new file mode 100644 index 0000000..17afc17 --- /dev/null +++ b/structure/21.tex @@ -0,0 +1,23 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname : Les commentaires multilignes} + + {Les commentaires multilignes sont compris entre les symboles \verb|/*| et \verb|*/|. + Tout texte, y compris les retours à la ligne, situé entre ces deux symboles est un commentaire.} + \begin{exampleblock}{Commentaire multiligne incluant du code} + \small\begin{verbatim} +int main() { + /* On n'affiche plus de message + puts("Hello World"); */ + return 0; +}\end{verbatim} + \end{exampleblock} + \begin{exampleblock}{Commentaire ``multiligne'' sur une partie d'une ligne} + \small\begin{verbatim} +int main() { + puts(/*"Hello World"*/"Bonjour !"); + return 0; +}\end{verbatim} + \end{exampleblock} +\end{frame} + diff --git a/structure/22.tex b/structure/22.tex new file mode 100644 index 0000000..25b2c86 --- /dev/null +++ b/structure/22.tex @@ -0,0 +1,18 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname : Les commentaires de fin de ligne} + + Les commentaires de fin de lignes sont symbolisés par \verb|//|. + \par + Tout ce qui suit le symbole \verb|//| est ignoré jusqu'au prochain retour à la ligne. + \par + Ce type de commentaire n'est disponible qu'en C99 et C++. + \begin{exampleblock}{Exemple de commentaire de fin de ligne} + \small\begin{verbatim} +int main() { + puts("Bonjour !"); + return 0; //XXX: should use EXIT_SUCCESS +}\end{verbatim} + \end{exampleblock} +\end{frame} + diff --git a/structure/23.tex b/structure/23.tex new file mode 100644 index 0000000..aac7c85 --- /dev/null +++ b/structure/23.tex @@ -0,0 +1,16 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname : Les commentaires de documentation} + Les commentaires de documentation sont encadrés par les symboles \verb|/**| et \verb|*/|. + \vspace{0.5cm} + \par + On les trouve principalement juste avant une déclaration de fonction, pour expliquer ce que fait cette fonction, le rôle de chaque paramètre, et leurs valeurs possibles, + des préconditions, expliquer les valeurs de retour et leur signification, les auteurs de la fonction, les dates de modification de la fonction, \ldots + \vspace{0.5cm} + \par + Ces commentaires sont récupérés de manière automatique par des logiciels comme \emph{Doxygen} afin de générer et formater des documentations au format HTML, notamment. + \vspace{0.5cm} + \par + La syntaxe de ces commentaires est identique à celle de JavaDoc. +\end{frame} + diff --git a/structure/24.tex b/structure/24.tex new file mode 100644 index 0000000..d1e383c --- /dev/null +++ b/structure/24.tex @@ -0,0 +1,14 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~I} + En C, les caractères blancs (espaces, tabulations, retour à la ligne) peuvent être utilisés sans restriction entre les opérateurs, les identificateurs, et tout autre élément de langage. + \vspace{0.5cm} + \par + Cela signifie qu'on est libre de la mise en forme du code. + \begin{exampleblock}{Code illisible mais valide} + \begin{verbatim} +int a=1;int main() {if(a) {faireQqch(); + return 0;}return 1;}\end{verbatim} + \end{exampleblock} +\end{frame} + diff --git a/structure/25.tex b/structure/25.tex new file mode 100644 index 0000000..5754ab8 --- /dev/null +++ b/structure/25.tex @@ -0,0 +1,21 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~II} + Afin de rendre le code plus lisible, on utilise une technique nommée \textbf{indentation}. + Elle consiste à faire précéder toute instruction d'un block d'un espacement de taille fixe (e.g. 4 espaces ou une tabulation) supplémentaire par rapport au block parent. + \begin{exampleblock}{Code lisible} + \begin{verbatim} +int a=1; + +int main() { + if(a) { + faireQqch(); + return 0; + } + return 1; +} \end{verbatim} + \end{exampleblock} + + +\end{frame} + diff --git a/structure/structure.tex b/structure/structure.tex new file mode 100644 index 0000000..07efc3d --- /dev/null +++ b/structure/structure.tex @@ -0,0 +1,67 @@ +\subsection*{helloworld.c} + +\input{structure/01} + +\subsection*{Les types de fichiers} + +\input{structure/02} + +\subsection*{Les fonctions en C} + +\input{structure/03} + +\input{structure/04} + +\input{structure/05} + +\input{structure/06} + +\subsection*{La fonction main()} + +\input{structure/07} + +\subsection*{L'appel de fonctions} + +\input{structure/08} + +\input{structure/09} + +\input{structure/10} + +\input{structure/11} + +\input{structure/12} + +\subsection*{Valeur de retour d'une fonction} + +\input{structure/13} + +\input{structure/14} + +\input{structure/15} + +\input{structure/16} + +\input{structure/17} + +\subsection*{Les caractères de fin d'instruction} + +\input{structure/18} + +\subsection*{Les commentaires} + +\input{structure/19} + +\input{structure/20} + +\input{structure/21} + +\input{structure/22} + +\input{structure/23} + +\subsection*{La mise en forme du code} + +\input{structure/24} + +\input{structure/25} diff --git a/variables/01.tex b/variables/01.tex new file mode 100644 index 0000000..384f33d --- /dev/null +++ b/variables/01.tex @@ -0,0 +1,13 @@ +\begin{frame} + \frametitle{\secname} + \framesubtitle{\subsecname} + + Une variable est une zone mémoire nommée et contenant une valeur. + \vspace{0.5cm} + \par + En C, les variables possèdent notamment un type qui définit quel genre d'information y est stockable. + \vspace{0.5cm} + \par + Les valeurs stockées dans les variables peuvent être modifiées par des opérations de transformation (mathématiques, \ldots). +\end{frame} + diff --git a/variables/02.tex b/variables/02.tex new file mode 100644 index 0000000..3c5b459 --- /dev/null +++ b/variables/02.tex @@ -0,0 +1,14 @@ +\begin{frame} + \frametitle{\secname} + \framesubtitle{\subsecname~I} + Les identificateurs, utilisés pour nommer les fonctions et les variables, sont formés d'une \textbf{combinaison de lettres (en majuscules ou en minuscules), + de chiffres et de caractères souligné (underscore).} + \vspace{0.5cm} + \par + Les deux seules limites sont qu'\textbf{un identificateur ne peut commencer par un chiffre} et qu'il ne doit pas être identique à un des mot-clés du langage. + \begin{block}{Les mot-clés en C} +auto, double, int, struct, break, else, long, switch, case, enum, register, typedef, char, extern, return, +union, const, float, short, unsigned, continue, for, signed, void, default, goto, sizeof,volatile, do, if, static, while + \end{block} +\end{frame} + diff --git a/variables/03.tex b/variables/03.tex new file mode 100644 index 0000000..1074fbb --- /dev/null +++ b/variables/03.tex @@ -0,0 +1,16 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~II} + + Les identificateurs doivent être un nom explicitant leur fonction dans le programme. Ils sont généralement exprimés en anglais. + \vspace{0.5cm} + \par + La seule exception est pour les compteurs qu'on nomme par convention \texttt{i}, \texttt{j} et \texttt{k}, lorsqu'il n'y a pas d'ambiguïté. + \vspace{0.5cm} + \par + Les identificateurs sont généralement nommés selon la notation CamelCase (premier mot en minuscule, mots suivant débutant par une majuscule)~: \texttt{thisIsAnExample} + \vspace{0.5cm} + \par + Les identificateurs sont ``case-sensitive''~: l'identificateur \verb|test| est différent de \verb|Test|. +\end{frame} + diff --git a/variables/04.tex b/variables/04.tex new file mode 100644 index 0000000..5e5a991 --- /dev/null +++ b/variables/04.tex @@ -0,0 +1,20 @@ +\begin{frame} + \frametitle{\secname} + \framesubtitle{\subsecname~III} + + Les variables sont parfois nommées selon la \href{http://fr.wikipedia.org/wiki/Notation_hongroise}{\textcolor{blue}{\underline{notation hongroise}}}~: + on préfixe le nom de la variable par une chaine d'un ou deux caractères rappelant le type de la variable. + \vspace{0.4cm} + \par + Les constantes ne suivent pas la notation CamelCase ; leur nom est uniquement composé de majuscules et les mots sont séparés par des underscores~: \texttt{MAX\_LENGTH} +% \vspace{0.4cm} +% \par +% Les fonctions portent en général un nom exprimant une action. Le nom commence donc souvent par un verbe à l'infinitif~: \texttt{showEditForm()} +% \vspace{0.4cm} +% \par +% Les fonctions sans effet de bord (calcul, \ldots) peuvent porter un nom qui n'est pas une action~: \texttt{sqrt()} + \vspace{0.4cm} + \par + Un bon identificateur est un nom \textbf{court mais explicite}. +\end{frame} + diff --git a/variables/05.tex b/variables/05.tex new file mode 100644 index 0000000..010d664 --- /dev/null +++ b/variables/05.tex @@ -0,0 +1,21 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: La déclaration~I} + + Une variable doit être déclarée avant de pouvoir être utilisée. + \vspace{0.5cm} + \par + La déclaration permet de définir le type d'une variable. + \vspace{0.5cm} + \par + Le type d'une variable reste le même de sa déclaration à sa fin de vie. + \vspace{0.5cm} + \par + \begin{block}{Syntaxe générale d'une déclaration de variable} + {\small\begin{verbatim} +[static] [const] type [*]identificateur [= expression] + [, [*]identificateur [= expression]...]; + \end{verbatim}} + \end{block} +\end{frame} + diff --git a/variables/06.tex b/variables/06.tex new file mode 100644 index 0000000..e049e56 --- /dev/null +++ b/variables/06.tex @@ -0,0 +1,13 @@ +\begin{frame} + \frametitle{\secname} + \framesubtitle{\subsecname~: La déclaration~II} + + La forme la plus simple de déclaration est de mettre sur une ligne le type de la variable, suivi de l'identificateur de cette variable, puis un point-virgule. + \vspace{0.5cm} + \par + Il est possible de définir plusieurs variables d'un même type lors d'une même déclaration en séparant les identificateurs par des virgules. + \vspace{0.5cm} + \par + L'identificateur peut être suivi d'une paire de crochets pour définir un tableau, ces crochets pouvant contenir une constante (ou une expression, en C99) définissant la taille du tableau. +\end{frame} + diff --git a/variables/07.tex b/variables/07.tex new file mode 100644 index 0000000..c6d4506 --- /dev/null +++ b/variables/07.tex @@ -0,0 +1,13 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: La déclaration~III} + + Chaque identificateur peut être précédé d'un astérisque~; cette variable est alors un pointeur sur le type déclaré, au lieu d'être du type déclaré. + \vspace{0.5cm} + \par + Le mot clé \verb|const| peut précéder le type~; les variables ainsi déclarées sont alors des constantes et leur valeur est théoriquement inaltérable jusqu'à leur fin de vie. + \vspace{0.5cm} + \par + Le mot clé \verb|static| permet de rendre la variable statique. +\end{frame} + diff --git a/variables/08.tex b/variables/08.tex new file mode 100644 index 0000000..7fbb0db --- /dev/null +++ b/variables/08.tex @@ -0,0 +1,18 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Initialisation des variables~I} + + Par défaut, une variable tout juste déclarée n'est pas initialisée, et contient une valeur indéterminée. + \vspace{0.5cm} + \par + Les variables statiques font exception à cette règle et sont automatiquement initialisées à 0. + \vspace{0.5cm} + \par + Il est nécessaire d'initialiser une variable avant de l'utiliser dans des opérations de transformation. + \vspace{0.5cm} + \par + Il est possible de stocker une valeur dans une variable dès sa déclaration. + \par + Pour cela, on fait suivre son identificateur du symbole \verb|=| suivi d'une expression~: une constante ou le résultat d'une opération. +\end{frame} + diff --git a/variables/09.tex b/variables/09.tex new file mode 100644 index 0000000..2d159f2 --- /dev/null +++ b/variables/09.tex @@ -0,0 +1,22 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Initialisation des variables~II} + + \begin{block}{Exemple de déclaration} + \begin{verbatim} +int i; + \end{verbatim} + \end{block} + \par + On déclare une variable \texttt{i} de type \texttt{int}. + \begin{block}{Exemple d'initialisation à la déclaration} + \begin{verbatim} +int i = 5, j, k=2+i; + \end{verbatim} + \end{block} + \par + Les trois variables sont de type \texttt{int}. + \par + Les variables \texttt{i} et \texttt{k} contiennent respectivement \texttt{5} et \texttt{7}. La variable \texttt{j} n'est pas initialisée. +\end{frame} + diff --git a/variables/10.tex b/variables/10.tex new file mode 100644 index 0000000..f1b3ef4 --- /dev/null +++ b/variables/10.tex @@ -0,0 +1,15 @@ +\begin{frame} + \frametitle{\secname} + \framesubtitle{\subsecname~: Vie et mort des variables~I} + + Une variable déclarée au sein d'un block est dite locale à ce block. Seules les instructions contenues dans ce block (et ses sous-blocks) peuvent ``voir'' cette variable et la manipuler. + \vspace{0.5cm} + \par + Une fonction est un block. Toutes les variables contenues dans le block de la fonction sont dites locales à la fonction. + Les paramètres d'une fonction sont considérés comme des variables locales. + \vspace{0.5cm} + \par + Une variable déclarée hors des fonctions (dans un fichier .c ou .h) est dite globale~: Elle est accessible en lecture et écriture par le code de toutes les fonctions. + +\end{frame} + diff --git a/variables/11.tex b/variables/11.tex new file mode 100644 index 0000000..c9cb2c3 --- /dev/null +++ b/variables/11.tex @@ -0,0 +1,14 @@ +\begin{frame} + \frametitle{\secname} + \framesubtitle{\subsecname~: Vie et mort des variables~II} + + Lorsque l'exécution sort d'un block, toutes les variables locales à ce block cessent d'exister. + \vspace{0.5cm} + \par + \begin{alertblock}{Retour sur les identificateurs} + Les noms des variables globales et des fonctions doivent être uniques au sein d'un \textbf{programme}. + \par + Les noms des variables locales doivent être uniques au sein d'un même block. + \end{alertblock} +\end{frame} + diff --git a/variables/12.tex b/variables/12.tex new file mode 100644 index 0000000..292cd22 --- /dev/null +++ b/variables/12.tex @@ -0,0 +1,23 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Vie et mort des variables~III} + + \begin{block}{Exemple de portée des variables} + \begin{verbatim} +int globalVar; + +int toto() { + int localVar1 = 1; + return localVar1; +} + +int main(int argc, char ** argv) { + int localVar1 = 0; + if(toto()) { + int localVar2 = 123; + } + return 0; +}\end{verbatim} + \end{block} +\end{frame} + diff --git a/variables/13.tex b/variables/13.tex new file mode 100644 index 0000000..63417bc --- /dev/null +++ b/variables/13.tex @@ -0,0 +1,17 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Vie et mort des variables~IV} + + \verb|globalVar| est une variable globale. Elle est accessible partout dans le programme (dans la fonction \verb|toto()| et dans la fonction \verb|main()|). + \vspace{0.5cm} + \par + \verb|argc|, \verb|argv|, \verb|localVar1| sont des variables locales à la fonction \verb|main()|. Elles sont accessibles partout dans la fonction \verb|main()|. + \vspace{0.5cm} + \par + \verb|localVar1| est une variable locale à la fonction \verb|toto()|. Seule la fonction \verb|toto()| peut accéder à cette variable. + Cette variable occupe un emplacement mémoire distinct de la variable éponyme de la fonction \verb|main()|. + \vspace{0.5cm} + \par + La variable \verb|localVar2| est locale au block \verb|if|. Elle cesse d'exister dès l'accolade fermante du block \verb|if|. +\end{frame} + diff --git a/variables/14.tex b/variables/14.tex new file mode 100644 index 0000000..0df4004 --- /dev/null +++ b/variables/14.tex @@ -0,0 +1,24 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Vie et mort des variables~V} + + {\small Une variable locale statique persiste en mémoire même lorsque l'exécution quitte le block qui l'a déclarée. + Cette variable n'est pas accessible en dehors de ce block, mais si l'exécution revient dans ce block, + la variable contiendra la valeur qu'elle avait lorsqu'on a quitté son block.} + \begin{exampleblock}{Exemple d'utilisation d'une variable statique} + {\small\begin{verbatim} +void countCall() { + static int i; + display(i++); // show the value of i and add 1 to it +} +int main() { + countCall(); // display 0 + countCall(); // display 1 + countCall(); // display 2 + return 0; +} + \end{verbatim}} + \end{exampleblock} + +\end{frame} + diff --git a/variables/15.tex b/variables/15.tex new file mode 100644 index 0000000..339e4b1 --- /dev/null +++ b/variables/15.tex @@ -0,0 +1,10 @@ +\begin{frame} + \frametitle{\secname} + \framesubtitle{\subsecname~I} + Le C comporte un grand nombre de types primitifs, différant par leur occupation mémoire et leur capacité de stockage. + \vspace{0.5cm} + \par + Tous les types primitifs sont numériques. Les lettres sont représentées sous forme numérique + (leur position dans la \href{http://www.asciitable.com/index/asciifull.gif}{\textcolor{blue}{\underline{table ASCII}}}). +\end{frame} + diff --git a/variables/16.tex b/variables/16.tex new file mode 100644 index 0000000..9665407 --- /dev/null +++ b/variables/16.tex @@ -0,0 +1,29 @@ +\begin{frame} + \frametitle{\secname} + \framesubtitle{\subsecname~II} + + Voici une liste des types primitifs~: + \par + {\footnotesize\begin{tabular}{|>{\centering\arraybackslash}m{2cm}|>{\centering\arraybackslash}m{1cm}|>{\centering\arraybackslash}m{3.2cm}|>{\centering\arraybackslash}m{3cm}|} +\hline +Type & Taille & Min & Max \\ +\hline +signed char & 8 bits & -128 & 127 \\ +\hline +unsigned char & 8 bits & 0 & 255 \\ +\hline +short (int)& 16 bits & -32768 & 32767 \\ +\hline +unsigned short (int) & 16 bits & 0 & 65535 \\ +\hline +int & 32 bits & -2147483648 & 2147483647 \\ +\hline +unsigned int & 32 bits & 0 & 4294967295 \\ +\hline +long (int) & 32 bits \linebreak ou \linebreak 64 bits & -2147483648 \linebreak ou \linebreak -9223372036854775808 & 2147483647 \linebreak ou \linebreak 9223372036854775807 \\ +\hline +unsigned long (int) & 32 bits \linebreak ou \linebreak 64 bits & 0 & 4294967295 \linebreak ou \linebreak 1844674407370955161 \\ +\hline + \end{tabular}} +\end{frame} + diff --git a/variables/17.tex b/variables/17.tex new file mode 100644 index 0000000..9dac077 --- /dev/null +++ b/variables/17.tex @@ -0,0 +1,22 @@ +\begin{frame} + \frametitle{\secname} + \framesubtitle{\subsecname~III} + + {\footnotesize\begin{tabular}{|>{\centering\arraybackslash}m{1.5cm}|>{\centering\arraybackslash}m{1cm}|>{\centering\arraybackslash}m{3cm}|>{\centering\arraybackslash}m{3cm}|} +\hline +long long (int) & 64 bits \linebreak ou \linebreak plus & \multicolumn{2}{|c|}{ça dépend} \\ +\hline +unsigned long long (int) & 64 bits \linebreak ou \linebreak plus & \multicolumn{2}{|c|}{ça dépend} \\ +\hline +float & 32 bits & 1.18e-38 & 3.4e38 \\ +\hline +double & 64 bits & 2.2250738585072014 \linebreak e-308 & 1.7976931348623157 \linebreak e308 \\ +\hline +long double & \multicolumn{3}{|c|}{ça dépend} \\ +\hline + \end{tabular}} + \vspace{0.5cm} + \par + Tous les types, primitifs ou composés peuvent être dérivés en pointeurs, de taille 32 ou 64 bits suivant l'architecture de la machine. +\end{frame} + diff --git a/variables/18.tex b/variables/18.tex new file mode 100644 index 0000000..9542c48 --- /dev/null +++ b/variables/18.tex @@ -0,0 +1,17 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~IV} + + \par + Le type \verb|void| n'a de sens que sous la forme de pointeur ou pour dire qu'une fonction ne retourne pas de valeur. + \vspace{0.5cm} + \par + Le type booléen n'existe pas en C89. On utilise généralement un \verb|char|. En C99, on peut avoir un type \verb|bool| en incluant la bibliothèque \verb|| (non disponible en C++). + \vspace{0.5cm} + \par + La taille d'un type, exprimée en octets, peut être connue via l'opérateur \texttt{sizeof}. + \vspace{0.5cm} + \par + Les bibliothèques \verb|| et \verb|| contiennent les valeurs limites de chaque type primitif. +\end{frame} + diff --git a/variables/19.tex b/variables/19.tex new file mode 100644 index 0000000..5cce901 --- /dev/null +++ b/variables/19.tex @@ -0,0 +1,20 @@ +\begin{frame} + \frametitle{\secname} + \framesubtitle{\subsecname~V} + + \par + Les valeurs limites peuvent être également retrouvées par simple calcul ! Inutile de mémoriser des séquences de plus de 10 chiffres ! + \vspace{0.2cm} + \par + Une valeur sur 8 bits est stockée sur huit 0 ou 1. Cela signifie que la valeur maximale est \textbf{11111111}. Chaque chiffre représente une puissance de 2, en commençant par $2^{0}$. Les indices vont donc de $2^{0}$ à $2^{7}$ pour une valeur sur 8 bits. + \vspace{0.2cm} + \par + La valeur $2^{8}$ vaut \textbf{100000000}. La valeur maximale stockée sur 8 bits est donc $2^{8} - 1$, soit 255. + \begin{block}{Valeur minimale et maximale} + La valeur maximale en mode non signé est $2^{nb de bits} - 1$ et la valeur minimale est 0. + \vspace{0.2cm} + \par + La valeur maximale en mode signé est $(2^{nb de bits} - 2)/2$ et la valeur minimale $-1 * (2^{nb de bits} / 2)$. + \end{block} +\end{frame} + diff --git a/variables/20.tex b/variables/20.tex new file mode 100644 index 0000000..0044957 --- /dev/null +++ b/variables/20.tex @@ -0,0 +1,18 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Les constantes nommées~I} + + Plus tôt, nous avons vu qu'il était possible de déclarer des variables avec le mot-clé \verb|const| devant le type. + \vspace{0.5cm} + \par + Il est nécessaire d'initialiser la constante à la déclaration, sans quoi la valeur constante sera une valeur indéterminée~! + \vspace{0.5cm} + \par + Il est également possible qu'un paramètre de fonction soit une constante. Dans ce cas, la valeur de l'argument est recopiée dans le paramètre, + et sa valeur ne pourra être changée pendant l'exécution de la fonction. + \begin{alertblock}{Passage de paramètres par valeur} + Attention~! Cela n'a rien à voir avec le fait que les arguments d'une fonction soient passés par valeur~! + \end{alertblock} + +\end{frame} + diff --git a/variables/21.tex b/variables/21.tex new file mode 100644 index 0000000..f1a2937 --- /dev/null +++ b/variables/21.tex @@ -0,0 +1,21 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Les constantes nommées~II} + \begin{block}{Déclaration et initialisation de constantes} + \begin{verbatim} +void toto(const int PARAMETER) { + const int UNKONWN_VALUE; + const int MAX_LIVES=9; + const int NB_OF_PLAYERS=PARAMETER+5; +}\end{verbatim} + \end{block} + \par + \verb|UNKNOWN_VALUE| contient maintenant une valeur indéterminée et qu'on ne peut plus changer~! + \vspace{0.3cm} + \par + \verb|MAX_LIVES| est une constante de valeur 9. + \vspace{0.3cm} + \par + \verb|NB_OF_PLAYERS| est une constante de valeur 5 + la valeur de la constante \verb|PARAMETER|, passée en paramètre à la fonction (et qui se trouve être, elle-même, une constante). +\end{frame} + diff --git a/variables/22.tex b/variables/22.tex new file mode 100644 index 0000000..43f3031 --- /dev/null +++ b/variables/22.tex @@ -0,0 +1,19 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Les constantes nommées~III} + + Un autre type de constantes est déclarable, par l'intermédiaire des directives préprocesseur. + \vspace{0.5cm} + \par + La valeur de ces constantes est déterminée à la compilation et le nom de la constante est remplacée par sa valeur dans le code, avant que le programme ne soit compilé. + \begin{block}{Exemple de constante défini par macro} + \begin{verbatim} +#define EXIT_SUCCESS 0 +int main() { + return EXIT_SUCCESS; +} + \end{verbatim} + \end{block} + Nous reviendrons sur les macros plus tard dans ce cours. +\end{frame} + diff --git a/variables/23.tex b/variables/23.tex new file mode 100644 index 0000000..d535fbd --- /dev/null +++ b/variables/23.tex @@ -0,0 +1,20 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Les constantes littérales~I} + + Outre les constantes nommées, il est possible d'utiliser des constantes littérales. + \vspace{0.3cm} + \par + Ces constantes sont également appelées ``valeurs en dur'' (hardcoded). + \vspace{0.3cm} + \par + Il s'agit de constantes dont la valeur est directement exprimée dans le code. + \vspace{0.3cm} + \par + Par défaut, tout nombre sans décimale ni exposant exprimé dans le code est une constante littérale de type \texttt{int}. + \begin{exampleblock}{0 est une constante littérale de type int} + \begin{verbatim} + return 0;\end{verbatim} + \end{exampleblock} +\end{frame} + diff --git a/variables/24.tex b/variables/24.tex new file mode 100644 index 0000000..d826416 --- /dev/null +++ b/variables/24.tex @@ -0,0 +1,23 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Les constantes littérales~II} + + Les nombres exprimés avec des décimales ou avec un exposant sont des constantes littérales de type \texttt{double}. + \par + \vspace{0.5cm} + Le chiffre suivant le \texttt{e} est la puissance de 10 par laquelle est multipliée le nombre. + + \begin{exampleblock}{Exemple de constantes littérales de type double} + 1.5 + \par + 12.98765 + \par + 1e3 // vaut $1 * 10^{3}$, soit 1000 + \par + 1.2345e2 // vaut $1,2345 * 10^{2}$, soit 123,45 + \par + 12345e-3 // vaut $12345 * 10^{-3}$, soit 12.345 + \end{exampleblock} + +\end{frame} + diff --git a/variables/25.tex b/variables/25.tex new file mode 100644 index 0000000..79585d8 --- /dev/null +++ b/variables/25.tex @@ -0,0 +1,32 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Les constantes littérales~II} + + Ces constantes sont limitées par leur type à des valeurs minimales et maximales. + \par + Il est possible de modifier le type d'une constante littérale en suffixant la valeur par un modificateur. + \begin{center} + \begin{tabular}{|c|c|c|} + \hline + Suffixe & Type & Exemple\\ + \hline + Aucun & int & 42 \\ + \hline + U ou u & unsigned int & 42U \\ + \hline + L ou l & long int & 42L \\ + \hline + UL ou ul & unsigned long int & 42UL \\ + \hline + LL ou ll & long long int & 42LL \\ + \hline + ULL ou ull & unsigned long long int & 42ULL \\ + \hline + F ou f & float & 4.2e1F \\ + \hline + L ou l (encore !) & long double & 4.2e1L \\ + \hline + \end{tabular} + \end{center} +\end{frame} + diff --git a/variables/26.tex b/variables/26.tex new file mode 100644 index 0000000..ddd928d --- /dev/null +++ b/variables/26.tex @@ -0,0 +1,19 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Les constantes littérales~III} + + Les caractères et les chaines de caractères peuvent également être des constantes littérales. + \vspace{0.5cm} + \par + Les caractères sont représentés entre apostrophes (simple quote). + \vspace{0.5cm} + \par + Les chaines de caractères sont représentées entre guillemets (double quotes). + \begin{exampleblock}{Caractère et chaine de caractères constantes} + \begin{verbatim} +'a' // constante caractère +"Hello, World" // constante chaine de caractères + \end{verbatim} + \end{exampleblock} +\end{frame} + diff --git a/variables/27-1.tex b/variables/27-1.tex new file mode 100644 index 0000000..a5be1f6 --- /dev/null +++ b/variables/27-1.tex @@ -0,0 +1,20 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Les constantes littérales~V} + + Les constantes littérales de type entier peuvent être exprimées en base 10, mais également dans d'autres bases. + \vspace{0.3cm} + \par + Il est possible d'exprimer des constantes en octal en faisant débuter la constante par un 0. + \begin{exampleblock}{Constante littérale en octal} + \begin{verbatim} +int a = 010; // a vaut 8 en décimal !\end{verbatim} + \end{exampleblock} + \par + Les constantes peuvent également être exprimées en héxadécimal, en préfixant le nombre avec \verb|0x|. + \begin{exampleblock}{Constante littérale en octal} + \begin{verbatim} +int a = 0x1a; // a vaut 26 en décimal !\end{verbatim} + \end{exampleblock} +\end{frame} + diff --git a/variables/27.tex b/variables/27.tex new file mode 100644 index 0000000..0ce29b7 --- /dev/null +++ b/variables/27.tex @@ -0,0 +1,17 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Les constantes littérales~IV} + + Comme les caractères sont stockés sous une forme numérique, il est possible d'effectuer des opérations + mathématiques dessus. + \begin{exampleblock}{Exemple d'addition sur un caractère} + \begin{verbatim} +char monCaractere = 'C' + 2; // monCaractere vaut 'E' + \end{verbatim} + \end{exampleblock} + \begin{alertblock}{Valable avec certains jeu de caractères uniquement~!} + Attention~! Ce type d'opération n'est valable qu'avec certains jeux de caractères, comme l'ASCII. + Cette exemple n'a comme vocation que d'illustrer que les caractères sont stockés sous forme numérique. + \end{alertblock} +\end{frame} + diff --git a/variables/28.tex b/variables/28.tex new file mode 100644 index 0000000..29fed6a --- /dev/null +++ b/variables/28.tex @@ -0,0 +1,21 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname} + + On peut définir de ``nouveaux'' types, avec pour avantages~: + \begin{itemize} + \item le renforcement du typage de votre programme + \item l'auto-documentation par le nom du type + \item une simplicité de refactorisation (i.e. changement d'un type pour passer à un autre (e.g. valeurs limites plus grandes)) + \end{itemize} + \begin{exampleblock}{Exemple de définition de types} + \begin{verbatim} +// Syntaxe : typedef nouveauType typeRedéfini; +typedef unsigned int mazewidth_t; +typedef unsigned int mazeheight_t; +void build(mazewidth_t w, mazeheight_t h);\end{verbatim} + \end{exampleblock} + \par + \texttt{typedef} devient encore plus pratique lorsqu'on ``aliase'' des pointeurs ou des types composés. +\end{frame} + diff --git a/variables/29.tex b/variables/29.tex new file mode 100644 index 0000000..59d8d87 --- /dev/null +++ b/variables/29.tex @@ -0,0 +1,35 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~I} + + La bibliothèque \verb|| définit de nouveaux types qui permettent de s'abstraire de la taille + réelle en mémoire des types primitifs (qui peut varier suivant les plateformes de compilation). + \begin{center} + {\footnotesize\begin{tabular}{|c|c|c|c|} + \hline + Type & Taille & Min & Max \\ + \hline + int8\_t & 8 bits & -128 & 127 \\ + \hline + uint8\_t & 8 bits & 0 & 255 \\ + \hline + int16\_t & 16 bits & -32768 & 32767 \\ + \hline + uint16\_t & 16 bits & 0 & 65535 \\ + \hline + int32\_t & 32 bits & -2147483648 & 2147483647 \\ + \hline + uint32\_t & 32 bits & 0 & 4294967295 \\ + \hline + int64\_t & 64 bits & -9223372036854775808 & 9223372036854775807 \\ + \hline + uint64\_t & 64 bits & 0 & 1844674407370955161 \\ + \hline + \end{tabular}} + \end{center} + \vspace{0.3cm} + \par + L'usage de ces types complexifie cependant légèrement l'usage des fonctions des familles \verb|printf()| et \verb|scanf()| que + nous verrons plus tard. +\end{frame} + diff --git a/variables/30.tex b/variables/30.tex new file mode 100644 index 0000000..c5e6556 --- /dev/null +++ b/variables/30.tex @@ -0,0 +1,17 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~II} + + \par + D'autres types ont été créés dans \verb||, tels que~: + \begin{itemize} + \item \verb|int_leastX_t| et \verb|uint_leastX_t|~: le type le plus petit existant sur la machine, mais de capacité au moins égale à X bits (avec X valant 8, 16, 32 ou 64)~; + \item \verb|int_fastX_t| et \verb|uint_fastX_t|~: le type le plus rapide existant sur la machine, mais de capacité au moins égale à X bits (avec X valant 8, 16, 32 ou 64)~; + \item \verb|intmax_t| et \verb|uintmax_t|~: le type pouvant stocker les plus grandes valeurs entières disponible sur la machine. + \end{itemize} + \vspace{0.5cm} + \par + Il faut noter cependant que C99 est encore peu usité et que ces types sont rarement rencontrés. On trouve plus fréquemment des palliatifs créés avant la norme C99, comme dans la bibliothèque libgnome~: \verb|gint8_t|, \ldots + +\end{frame} + diff --git a/variables/31.tex b/variables/31.tex new file mode 100644 index 0000000..a7e58fa --- /dev/null +++ b/variables/31.tex @@ -0,0 +1,18 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~III} + + Les types définis par \verb|| voient leurs bornes définis dans des constantes de type macro (directives préprocesseur). + \vspace{0.5cm} + \begin{itemize} + \item \verb|intX_t|~: \verb|INT8_MIN| et \verb|INT8_MAX| jusqu'à \verb|INT64_MIN| et \verb|INT64_MAX|~; + \item \verb|uintX_t|~: \verb|UINT8_MAX| jusqu'à \verb|UINT64_MAX|~; + \item \verb|int_leastX_t|~: \verb|INT_LEAST8_MIN| et \verb|INT_LEAST8_MAX| jusqu'à \verb|INT_LEAST64_MIN| et \verb|INT_LEAST64_MAX|~; + \item \verb|uint_leastX_t|~: \verb|UINT_LEAST8_MAX| jusqu'à \verb|UINT_LEAST64_MAX|~; + \item \verb|int_fastX_t|~: \verb|INT_FAST8_MIN| et \verb|INT_FAST8_MAX| jusqu'à \verb|INT_FAST64_MIN| et \verb|INT_FAST64_MAX|~; + \item \verb|uint_fastX_t|~: \verb|UINT_FAST8_MAX| jusqu'à \verb|UINT_FAST64_MAX|~; + \item \verb|intmax_t|~: \verb|INTMAX_MIN| et \verb|INTMAX_MAX|~; + \item \verb|uintmax_t|~: \verb|UINTMAX_MAX|. + \end{itemize} +\end{frame} + diff --git a/variables/32.tex b/variables/32.tex new file mode 100644 index 0000000..3debf7f --- /dev/null +++ b/variables/32.tex @@ -0,0 +1,20 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~I} + + Cette multitude de types, primitifs, aliasés ainsi que les types composés ne sont pas nécessairement compatibles entre eux. Selon le vieil adage, + on ne peut comparer des pommes et des poires\ldots + \vspace{0.3cm} + \par + Nous reviendrons plus tard sur l'opérateur d'affectation ; considérons pour l'instant que le symbole \verb|=| permet de stocker la valeur ou + expression à droite du symbole, dans la ``variable'' à gauche de ce dernier (on appelle cette partie une \verb|LVALUE|). + \vspace{0.3cm} + \begin{exampleblock}{Affectation d'une valeur à une variable} + \begin{verbatim} +int a, b; +a = 5; // a vaut 5, b est indéfini +b = a; // a vaut toujours 5, mais b aussi +a = 7; // a vaut désormais 7, b reste à la valeur 5 + // affectée précédemment \end{verbatim} + \end{exampleblock} +\end{frame} diff --git a/variables/33.tex b/variables/33.tex new file mode 100644 index 0000000..363a8d9 --- /dev/null +++ b/variables/33.tex @@ -0,0 +1,18 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~II} + + Lorsqu'on affecte une valeur d'un type à une variable du même type, tout va bien. + \par + Que se passe-t-il cependant si on affecte un \verb|int|, à une variable de type \verb|short| ? Quid d'un \verb|float| affecté à un \verb|int| ? + \par + Si la valeur \verb|int| est supérieure à \verb|SHRT_MAX| ou inférieure à \verb|SHRT_MIN|, alors il risque + d'il y avoir une perte d'information. Le compilateur émet alors parfois un warning pour vous prévenir. + \vspace{0.5cm} + \par + La coercition de type permet dans ce cas, et dans bien d'autres de signaler que vous prenez la responsabilité de cette conversion. + \vspace{0.5cm} + \par + La coercition de type s'écrit en faisant précéder une expression du type dans lequel on souhaite convertir la valeur, entre parenthèses. +\end{frame} + diff --git a/variables/34.tex b/variables/34.tex new file mode 100644 index 0000000..c018a0f --- /dev/null +++ b/variables/34.tex @@ -0,0 +1,23 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~III} + + \begin{exampleblock}{Exemple de conversion d'un int en short} + \begin{verbatim} +void toto(int a) { + short b; + + // b = a aurait généré un warning + b = (short) a; + b = (short)(a + 10); //cast de a + 10 en short +}\end{verbatim} + \end{exampleblock} + \begin{exampleblock}{Exemple de conversion d'un int en short} + \begin{verbatim} +float a=3.5; +int b; +//b = a cause un warning +b = (int) a; // a vaut 3,5 et b 3\end{verbatim} + \end{exampleblock} +\end{frame} + diff --git a/variables/35.tex b/variables/35.tex new file mode 100644 index 0000000..315e312 --- /dev/null +++ b/variables/35.tex @@ -0,0 +1,18 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~IV} + + Les coercitions de type sont également très utilisées lorsqu'on utilise des aliases de type, définis avec \verb|typedef|. + \begin{exampleblock}{Conversion d'un uint8\_t en unsigned char} + \begin{verbatim} +uint8_t a = 8; +unsigned char b; +b = (unsigned char) a; + \end{verbatim} + \end{exampleblock} + \vspace{0.5cm} + \par + La coercition de type est également très utilisée pour convertir des pointeurs, notamment de type \verb|void *|. + \par Nous reviendrons sur ce point ultérieurement dans le cours. +\end{frame} + diff --git a/variables/36.tex b/variables/36.tex new file mode 100644 index 0000000..8c5f0b5 --- /dev/null +++ b/variables/36.tex @@ -0,0 +1,22 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~V} + + \begin{alertblock}{Conversion ascendante automatique} + La conversion vers des types de plus grandes tailles numérique se fait automatiquement, puisqu'il n'y a pas de risque de perte de l'information. + \vspace{0.3cm} + \par + Il existe cependant un grand danger~: les types non signés sont plus grands que leurs versions signées. + Autrement dit un \verb|int| peut être promu automatiquement en \verb|unsigned int|. + \vspace{0.3cm} + \par + Cela ne pause aucun problème pour les valeurs positives, mais pour les valeurs négatives, il y a danger !! + \vspace{0.3cm} + \par + La valeur $-1$ vaut 32 bits à 1, dans un \verb|int|. + \vspace{0.3cm} + \par + 32 bits à 1 est une valeur parfaitement acceptable dans un \verb|unsigned int|~: 4294967295. + \end{alertblock} +\end{frame} + diff --git a/variables/37.tex b/variables/37.tex new file mode 100644 index 0000000..9197ec1 --- /dev/null +++ b/variables/37.tex @@ -0,0 +1,17 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~VI} + + \begin{exampleblock}{Promotion automatique d'un entier négatif et son danger} + \begin{verbatim} + int a = -1; + unsigned int b; + b = a; // a vaut -1 + // b vaut 4294967295 par promotion auto. + \end{verbatim} + \end{exampleblock} + \begin{block}{Vocabulaire~: coercition, casting, \ldots} + En français, on parle de coercition de type. En anglais, on parle de \textbf{casting}. On ``\textbf{cast}'' une variable dans un autre type. + \end{block} +\end{frame} + diff --git a/variables/38.tex b/variables/38.tex new file mode 100644 index 0000000..05397d7 --- /dev/null +++ b/variables/38.tex @@ -0,0 +1,31 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~VII} + + Les valeurs numériques subissent, comme l'exemple précédent nous l'a démontré, des promotions automatiques entre types. + \vspace{0.5cm} + \par + Voici un tableau illustrant les promotions implicites (de bas en haut)~: + \begin{tabular}{|m{10cm}|} + \hline + \verb|long double| \\ + \hline + \verb|double| \\ + \hline + \verb|float| \\ + \hline + \verb|unsigned long| \\ + \hline + \verb|long| \\ + \hline + \verb|unsigned int| \\ + \hline + \verb|int| \\ + \hline + \end{tabular} + \vspace{0.5cm} + \par + Les types \verb#signed|unsigned char#, \verb#signed|unsigned short# sont automatiquement promus en \verb|int| lors d'une opération mathématique, + avant d'être éventuellement rétrogradés. +\end{frame} + diff --git a/variables/39.tex b/variables/39.tex new file mode 100644 index 0000000..54240a7 --- /dev/null +++ b/variables/39.tex @@ -0,0 +1,20 @@ +\begin{frame} + \frametitle{\secname} + \framesubtitle{\subsecname~: Les structures~I} + + Il est possible d'agglomérer plusieurs informations au sein d'un même type de données. + \vspace{0.3cm} + \par + Pour cela, on définit un nouveau type de données, une \textbf{structure}, en précisant quelles informations + la compose. + \vspace{0.3cm} + \par + Une structure peut regrouper tous types de données précédemment déclarés, que ce soit des types primitifs, + d'autres structures, des énumérations, des unions, des pointeurs de tous types, des tableaux \ldots + \vspace{0.3cm} + \par + La structure agit comme un regroupement de taille arbitraire de variables. Chacune des variables ainsi + regroupées porte un nom permettant d'accéder à son espace mémoire, en vue d'y consulter la valeur + stockée ou de la modifier. +\end{frame} + diff --git a/variables/40.tex b/variables/40.tex new file mode 100644 index 0000000..9f86073 --- /dev/null +++ b/variables/40.tex @@ -0,0 +1,18 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Les structures~II} + + \begin{block}{Syntaxe générale de déclaration d'une structure} + \begin{verbatim} +struct NomDeLaStructure { + type nomMembre; + type nomMembre2; + ... +};\end{verbatim} + \end{block} + \vspace{0.5cm} + \par + On note que le nom du type d'une structure suit la notation CamelCase, avec la première lettre du premier mot + également en majuscule. +\end{frame} + diff --git a/variables/41.tex b/variables/41.tex new file mode 100644 index 0000000..a3a92c6 --- /dev/null +++ b/variables/41.tex @@ -0,0 +1,24 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Les structures~III} + + \begin{exampleblock}{Exemple de déclaration d'une structure} + \begin{verbatim} +struct Date { + unsigned char jour; // uint_fast8_t ? + unsigned char mois; // uint_fast8_t ? + short annee; // B.C. & A.C. // int_fast16_t ? +};\end{verbatim} + \end{exampleblock} + \vspace{0.3cm} + \par + On déclare une variable du type d'une structure déclarée en faisant précéder le nom de la variable du mot-clé + \verb|struct| suivi du nom de la structure. + + \begin{exampleblock}{Déclaration d'une variable de type \texttt{struct Date}} + \begin{verbatim} +struct Date maDate; // la variable maDate est de + // type struct Date\end{verbatim} + \end{exampleblock} +\end{frame} + diff --git a/variables/42.tex b/variables/42.tex new file mode 100644 index 0000000..7a4dd55 --- /dev/null +++ b/variables/42.tex @@ -0,0 +1,21 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Les structures~IV} + + Chaque variable d'un même type structuré possède un espace mémoire distinct pour chacun de ses membres. Autrement dit, soit une structure avec + deux membres a et b, et deux variables x et y du type de cette structure, alors le membre a de la variable est distinct en mémoire du membre a + de la variable y. + \vspace{0.3cm} + \par + Une fois qu'une variable de type structure est définie, on peut accéder à ses membres (les variables composant la structure) à l'aide + de l'opérateur \verb|.| (point). + {\small\begin{exampleblock}{Accès aux membres d'une structure} + \begin{verbatim} +struct Date maDate, monAnniversaire; +maDate.jour = 2; +monAnniversaire.jour = 3; +maDate.mois = 1; +monAnniversaire.mois = maDate.mois;\end{verbatim} + \end{exampleblock}} +\end{frame} + diff --git a/variables/43.tex b/variables/43.tex new file mode 100644 index 0000000..f524b0e --- /dev/null +++ b/variables/43.tex @@ -0,0 +1,22 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Les structures~IV} + + Il est possible d'initialiser une variable d'un type structuré lors de sa déclaration. + \vspace{0.3cm} + \par + Pour cela, on utilise les accolades pour représenter la structure, et la virgule comme séparateur de valeurs pour les membres. + Les membres sont initialisés dans l'ordre de leur figuration dans la structure lors de sa déclaration. + \vspace{0.3cm} + \begin{exampleblock}{Initialisation d'une variable de type structuré} + \begin{verbatim} +#include +struct Date { + uint8_t jour; + uint8_t mois; + int16_t annee; +}; +struct Date today = { 29, 10, 2011 };\end{verbatim} + \end{exampleblock} +\end{frame} + diff --git a/variables/44.tex b/variables/44.tex new file mode 100644 index 0000000..2cef6b6 --- /dev/null +++ b/variables/44.tex @@ -0,0 +1,17 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Les structures~IV} + + Il est possible d'imbriquer des structures. Dans l'exemple suivant, \verb|char *| désigne une chaine de caractères. + Nous les verrons plus tard dans ce cours. + \vspace{0.5cm} + \begin{exampleblock}{Imbriquation de structures} + \begin{verbatim} +struct Personne { + char * nom; + char * prenom; + struct Date dateDeNaissance; +};\end{verbatim} + \end{exampleblock} +\end{frame} + diff --git a/variables/45.tex b/variables/45.tex new file mode 100644 index 0000000..1d44278 --- /dev/null +++ b/variables/45.tex @@ -0,0 +1,20 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Les structures~V} + + Afin d'économiser la frappe clavier, et de rendre plus lisible le code, il est possible d'effectuer un + \verb|typedef| de ``\verb|struct NomStructure|''. + \vspace{0.3cm} + \par + Le \verb|typedef| peut se faire au moment de la déclaration de la structure, ou dans un second temps. + \vspace{0.3cm} + {\small\begin{exampleblock}{Typedef de structures} + \begin{verbatim} + struct Toto { int a; int b; }; + typedef struct Toto Toto; + typedef struct Titi { int a ; int b ;} Titi; + Toto monToto; //équivalent à struct Toto monToto; + Titi monTiti; //équivalent à struct Toto monToto;\end{verbatim} + \end{exampleblock}} +\end{frame} + diff --git a/variables/46.tex b/variables/46.tex new file mode 100644 index 0000000..95be091 --- /dev/null +++ b/variables/46.tex @@ -0,0 +1,20 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Les structures~VI} + + Il est possible d'effectuer une déclaration de variables du type de la structure dans la foulée de la déclaration + de la-dite structure en faisant suivre la déclaration du nom d'une ou plusieurs variables, séparées par des + virgules, avant de terminer par un point-virgule. + \vspace{0.3cm} + \begin{exampleblock}{Déclaration de variables dans la déclaration} + \begin{verbatim} +struct Exemple { + int a; + int b; +} maVar1, maVar2, maVar3;\end{verbatim} + \end{exampleblock} + \vspace{0.3cm} + \par + Les variables \verb|maVar1|, \verb|maVar2| et \verb|maVar3| sont toutes de type \verb|struct Exemple|. +\end{frame} + diff --git a/variables/47.tex b/variables/47.tex new file mode 100644 index 0000000..fca37ec --- /dev/null +++ b/variables/47.tex @@ -0,0 +1,13 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Les structures~VII} + + Dans le cas où l'on déclare une structure à l'intérieur d'une instruction \verb|typedef|, il est possible d'omettre + le nom de la structure. On appelle cela une structure \textbf{anonyme}. + \vspace{0.5cm} + \par + Une structure anonyme peut également être utilisée pour déclarer une série de variables. Dès la fin de la + déclaration de ces variables, la structure est oubliée, mais ces variables continuent d'occuper la mémoire selon + le schéma défini par cette structure. +\end{frame} + diff --git a/variables/48.tex b/variables/48.tex new file mode 100644 index 0000000..8605481 --- /dev/null +++ b/variables/48.tex @@ -0,0 +1,25 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Les structures~VIII} + + {\small\begin{exampleblock}{Exemples de structures anonymes} + \begin{verbatim} +typedef struct { + int a; + char b; +} Toto; + +Toto maVar1; + +struct { + char a; + int b; +} maVar2; + \end{verbatim} + \end{exampleblock}} + \par + \verb|maVar1| est de type \verb|Toto|. + \par + \verb|maVar2| est d'un type anonyme, structure ayant deux membres \verb|a| de type \verb|char| et \verb|b| + de type \verb|int|. +\end{frame} diff --git a/variables/49.tex b/variables/49.tex new file mode 100644 index 0000000..42d9105 --- /dev/null +++ b/variables/49.tex @@ -0,0 +1,22 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Les énumérations~I} + + Il est souvent souhaitable d'abstraire un mécanisme sous-jacent pour rendre le code plus expressif. + \vspace{0.3cm} + \par + Par exemple, imaginons que l'on parle d'une structure représentant une voiture. L'une des caractéristiques + de la voiture (et donc un des membres de sa structure) est sa couleur de carrosserie. Nous allons probablement + utiliser un code couleur pour cela (0 = rouge, 1 = bleu, 2 = vert, \ldots). + \vspace{0.3cm} + \par + Afin de rendre le code plus lisible, et ne pas retrouver des 0, 1, 2, \ldots dans notre code, le premier réflexe + pourrait être de créer des constantes globales, ou des macros. + \begin{exampleblock}{Constantes colorées} + \begin{verbatim} +#define COULEUR_VOITURE_BLEU 1 +// ou +const int COULEUR_VOITURE_BLEU = 1;\end{verbatim} + \end{exampleblock} +\end{frame} + diff --git a/variables/50.tex b/variables/50.tex new file mode 100644 index 0000000..d18a443 --- /dev/null +++ b/variables/50.tex @@ -0,0 +1,19 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Les énumérations~II} + + Le défaut de cette approche est que le typage est plutôt faible~: la couleur est un entier, pas une couleur. Si + cela ne change rien au niveau technique, c'est le niveau sémantique (et donc la lisibilité) qui en pâtit. + \vspace{0.3cm} + \par + Prenons l'exemple d'une fonction modifiant la couleur d'une voiture fournie en paramètre. Son prototype serait~: + \begin{verbatim} +int setCarColor(struct Car *car, int c);\end{verbatim} + \vspace{0.3cm} + \par + On peut s'interroger sur cet \verb|int| utilisé comme paramètre. + \par + Par ailleurs, il faut définir les couleurs unes à unes, en prenant en charge leur numérotation manuellement. + Tout ceci est fastidieux et peu expressif. +\end{frame} + diff --git a/variables/51.tex b/variables/51.tex new file mode 100644 index 0000000..aaf59fc --- /dev/null +++ b/variables/51.tex @@ -0,0 +1,18 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Les énumérations~III} + + Dans l'exemple précédent, il aurait été possible d'effectuer un typedef. + \vspace{0.3cm} + \begin{exampleblock}{Exemple de voiture colorée avec typedef} + \begin{verbatim} +typedef int carcolor_t; +int setCarColor(struct Car *car, carcolor_t c);\end{verbatim} + \end{exampleblock} + \vspace{0.3cm} + \par + Fort heureusement, tout ceci a été simplifié en C~: les \textbf{énumérations} permettent de définir un nouveau + type contenant des constantes dont la numérotation est automatiquement prise en charge ! On ne manie donc plus + des chiffres, mais bien des \textbf{symboles}. +\end{frame} + diff --git a/variables/52.tex b/variables/52.tex new file mode 100644 index 0000000..0cdfd2a --- /dev/null +++ b/variables/52.tex @@ -0,0 +1,20 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Les énumérations~IV} + + \begin{block}{Syntaxe générale d'une énumération} + \begin{verbatim} +enum NomEnumeration { + membre1, + membre2, + ... + membreN +}; \end{verbatim} + \end{block} + \vspace{0.3cm} + \par + Le membre1 reçoit la valeur 0, le membre2, la valeur 1, \ldots Nous n'en avons cependant rien à faire ! Nous manions + maintenant des \textbf{symboles} (``membre1'', ``membre2'') sans nous soucier des valeurs numériques qui y sont + affectées~: nous nous sommes abstrait la représentation en mémoire. +\end{frame} + diff --git a/variables/53.tex b/variables/53.tex new file mode 100644 index 0000000..06dc92c --- /dev/null +++ b/variables/53.tex @@ -0,0 +1,21 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Les énumérations~V} + + Il est possible, dès lors, de déclarer des variables du type énumération. Comme avec les structures, le mot-clé + \verb|enum| doit précéder le nom du type. Il est cependant possible d'utiliser un typedef. + \vspace{0.3cm} + \begin{exampleblock}{Exemple d'utilisation d'énumérations} + \begin{verbatim} +enum CarColor { red, blue, green }; +typedef enum CarColor CarColor_t; + +int setCarColor(struct Car *car, enum CarColor c); + +enum CarColor uneCouleur; +uneCouleur = red; + +setCarColor(&c, blue):\end{verbatim} + \end{exampleblock} +\end{frame} + diff --git a/variables/54.tex b/variables/54.tex new file mode 100644 index 0000000..d3f36af --- /dev/null +++ b/variables/54.tex @@ -0,0 +1,23 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Les énumérations~VI} + + Il est possible de forcer la numérotation des constantes d'une énumération. Cela peut être utile, notamment lorsqu'on + définit un \textit{champ de bits}. Nous reviendrons sur les champs de bits lorsque nous aborderons les opérateurs + binaires. + \vspace{0.3cm} + \par + Notons simplement la syntaxe pour le moment. + \begin{exampleblock}{Champ de bits avec des énumérations} + \begin{verbatim} +enum OptionsVoiture { + opt_ABS = 1, + opt_Climatisation = 1<<1, + opt_VitresElectriques = 1<<2, + opt_FermetureCentralisee = 1<<3 +}; +enum OptionsVoiture myOptions; +myOptions = opt_ABS | opt_VitresEletriques;\end{verbatim} + \end{exampleblock} +\end{frame} + diff --git a/variables/55.tex b/variables/55.tex new file mode 100644 index 0000000..d4b87af --- /dev/null +++ b/variables/55.tex @@ -0,0 +1,21 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Les énumérations~VII} + + \begin{alertblock}{Faible typage des énumérations !} + Le C n'est cependant pas un langage au typage très fort. Toutes ces constantes restent des \verb|int| et sont + malheureusement compatibles entre elles ! + \vspace{0.3cm} + \par + Le code suivant, par exemple ne provoquera aucune erreur ! + \par + \begin{verbatim} +enum color { red, blue, green }; +enum ingredients { cheese, mushrooms, tomato }; +enum color myColor; + +myColor = cheese; // Aucune erreur ni warning +myColor = 254; // Ici non plus :(\end{verbatim} + \end{alertblock} +\end{frame} + diff --git a/variables/56.tex b/variables/56.tex new file mode 100644 index 0000000..54f0c63 --- /dev/null +++ b/variables/56.tex @@ -0,0 +1,17 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Les unions~I} + Pour stocker en mémoire une structure, la place occupée par chacun de ses membres est sommée afin de déterminer + la taille totale que chaque variable de ce type structuré occupe. S'y ajoute, pour une sombre histoire + d'\href{http://fr.wikipedia.org/wiki/Alignement_en_m\%C3\%A9moire}{\textcolor{blue}{\underline{alignement mémoire}}}, + quelques octets dans certains cas, mais nous ignorerons ce détail, pour des raisons de simplification. + \vspace{0.5cm} + \par + Ainsi, pour une structure X, composée de deux membres a (un \verb|int|) et b (un \verb|double|), la taille + d'une variable Y de type \verb|struct X| est de 12 octets (taille d'un int + taille d'un double, soit $4 + 8$). + \vspace{0.5cm} + \par + Les membres \verb|Y.a| et \verb|Y.b| occupent deux emplacements de 4 et 8 octets en mémoire distincts et contigües + et pouvant stocker deux valeurs indépendantes. +\end{frame} + diff --git a/variables/57.tex b/variables/57.tex new file mode 100644 index 0000000..4b98836 --- /dev/null +++ b/variables/57.tex @@ -0,0 +1,19 @@ +\begin{frame} + \frametitle{\secname} + \framesubtitle{\subsecname~: Les unions~II} + + Il existe un autre type de données, en C, très proche des structures mais au but fondamentalement différent~: + les \textbf{unions}. + \vspace{0.3cm} + \par + Au contraire des structures dont les membres occupent une place en mémoire distincte, les membres d'une union + (qui peuvent être de tous types, y compris composés) partagent le même emplacement mémoire. + C'est-à-dire que pour une union X ayant deux membres a (un int) et b (un double), la taille en mémoire de + l'union sera de 8 octets, soit la taille qu'occupe en mémoire le plus grand de ses membres. + \vspace{0.3cm} + \par + Occupant le même emplacement mémoire, seul l'un des membres d'une union peut stocker une valeur à un moment T. + \par + On utilise alors généralement une énumération et une structure pour noter quel membre contient la valeur. +\end{frame} + diff --git a/variables/58.tex b/variables/58.tex new file mode 100644 index 0000000..47f5f13 --- /dev/null +++ b/variables/58.tex @@ -0,0 +1,22 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Les unions~II} + + L'opérateur d'accès est toujours le point. Il faut préciser quel membre reçoit une valeur, ou est lu, malgré que + l'on parle d'un même emplacement mémoire. + \vspace{0.3cm} + \begin{block}{Syntaxe générale d'une union} + \begin{verbatim} +union NomDeLUnion { + int a; + double b; +}; + +union NomDeLUnion maVariable; +maVariable.a = 2;\end{verbatim} + \end{block} + \vspace{0.3cm} + \par + On notera que les unions sont assez rarement employées. +\end{frame} + diff --git a/variables/59.tex b/variables/59.tex new file mode 100644 index 0000000..365de0c --- /dev/null +++ b/variables/59.tex @@ -0,0 +1,23 @@ +\begin{frame}[containsverbatim] + \frametitle{\secname} + \framesubtitle{\subsecname~: Les unions~III} + + {\small\begin{exampleblock}{Exemple d'une union anonyme dans une structure} + \begin{verbatim} +struct Storage { + // union anonyme + union { + int a; + float b; + } value; + // enumeration anonyme + enum { + intVal, + floatVal + } type; +}; +struct Storage s; +s.value.a = 3; +s.type = intVal;\end{verbatim} + \end{exampleblock}} +\end{frame} diff --git a/variables/variables.tex b/variables/variables.tex new file mode 100644 index 0000000..c6c5e13 --- /dev/null +++ b/variables/variables.tex @@ -0,0 +1,137 @@ +\subsection*{Qu'est ce qu'une variable ?} + +\input{variables/01} + +\subsection*{Les identificateurs} + +\input{variables/02} + +\input{variables/03} + +\input{variables/04} + +\subsection*{Cycle de vie des variables} + +\input{variables/05} + +\input{variables/06} + +\input{variables/07} + +\input{variables/08} + +\input{variables/09} + +\input{variables/10} + +\input{variables/11} + +\input{variables/12} + +\input{variables/13} + +\input{variables/14} + +\subsection*{Les types de données primitifs} + +\input{variables/15} + +\input{variables/16} + +\input{variables/17} + +\input{variables/18} + +\input{variables/19} + +\subsection*{Les constantes} + +\input{variables/20} + +\input{variables/21} + +\input{variables/22} + +\input{variables/23} + +\input{variables/24} + +\input{variables/25} + +\input{variables/26} + +\input{variables/27} + +\input{variables/27-1} + +\subsection*{Définition de types} + +\input{variables/28} + +\subsection*{C99~: Types définis par $<$stdint.h$>$} + +\input{variables/29} + +\input{variables/30} + +\input{variables/31} + +\subsection*{Coercition de type (casting)} + +\input{variables/32} + +\input{variables/33} + +\input{variables/34} + +\input{variables/35} + +\input{variables/36} + +\input{variables/37} + +\input{variables/38} + +\subsection*{Les types de données composés} + +\input{variables/39} + +\input{variables/40} + +\input{variables/41} + +\input{variables/42} + +\input{variables/43} + +\input{variables/44} + +\input{variables/45} + +\input{variables/46} + +\input{variables/47} + +\input{variables/48} + +\input{variables/49} + +\input{variables/50} + +\input{variables/51} + +\input{variables/52} + +\input{variables/53} + +\input{variables/54} + +\input{variables/55} + +\input{variables/56} + +\input{variables/57} + +\input{variables/58} + +\input{variables/59}