log1-chapitre-structure.tex

% ==================================
\chapter{Les variables structurées}
% ==================================

% ==========================
\section{Le type structuré}
% ==========================

	Dans les chapitres précédents, nous avons utilisé des variables de types
	dits «~simples~» (entier, réel, booléen, caractère, chaine) ne pouvant
	contenir qu’une seule valeur à la fois. Cependant, certains types
	d’information consistent en un regroupement de plusieurs données
	élémentaires. Quelques exemples~:

	\begin{liste}
	\item {
		une \textbf{date} est composée de trois éléments (le jour, le mois,
		l’année), le mois s’exprimant, selon le format,
		tantôt par un entier (15/10/2014) tantôt
		par une chaine (15~octobre~2014)}
	\item {
		un \textbf{moment} de la journée est un triple d’entiers (heures,
		minutes, secondes)}
	\item {
		la localisation d’un \textbf{point} dans un plan nécessite la
		connaissance de deux coordonnées cartésiennes (l’abscisse \textit{x} et
		l’ordonnée \textit{y}) ou polaires (le rayon \textit{r} et l’angle
		\textit{$\theta$})}
	\item {
		une \textbf{adresse} est composée de plusieurs données~:~un nom de rue,
		un numéro de maison, parfois un numéro de boite postale, un code
		postal, le nom de la localité, un nom ou code de pays pour une adresse
		à l’étranger\dots}
	\end{liste}

	Pour stocker et manipuler de tels ensembles de données, nous utiliserons
	des \textbf{types structurés} ou \textbf{structures}\footnote{Nous
	verrons dans un chapitre ultérieur que l’approche
	«~orientée objet~» offre également une solution élégante pour manipuler
	des données complexes.}. Une \textbf{structure} est donc un ensemble
	fini d’éléments pouvant être de types distincts. Chaque élément de cet
	ensemble, appelé \textbf{champ} de la structure, possède un nom unique.
	
	Notez qu’un champ d’une structure peut lui-même être une structure. Par
	exemple, une \textbf{carte d’identité} inclut parmi ses informations
	une \textbf{date} de naissance, l’\textbf{adresse} de son
	propriétaire (cachée dans la puce électronique~!),\dots

% ===================================
\section{Définition d’une structure}
% ===================================

	\marginicon{definition}
	La définition d’un type structuré adoptera le modèle suivant~:

	\cadre{
	\begin{pseudo}
	\Struct{NomDeLaStructure}
		\Decl nomChamp1 : type1
		\Decl nomChamp2 : type2
		\Decl \dots
		\Decl nomChampN : typeN
	\EndStruct
	\end{pseudo}
	}

	\textstyleCodeInsr{nomChamp1}, \dots, \textstyleCodeInsr{nomChampN} 
	sont les noms des différents champs de la structure, 
	et \textstyleCodeInsr{type1}, \dots, \textstyleCodeInsr{typeN} 
	les types de ces champs. 
	Ces types sont soit les types «~simples~» étudiés
	précédemment (entier, réel, booléen, caractère, chaine) soit d’autres
	types structurés dont la structure aura été préalablement définie.

	Pour exemple, nous définissons ci-dessous trois
	types structurés que nous utiliserons souvent par la suite~:

	\cadre{
	\begin{pseudo}
	\Struct{Date}
		\Decl jour : entier
		\Decl mois : entier
		\Decl année : entier
	\EndStruct
	\end{pseudo}
	}

	\cadre{
	\begin{pseudo}
	\Struct{Moment}
		\Decl heure : entier
		\Decl minute : entier
		\Decl seconde : entier
	\EndStruct
	\end{pseudo}
	}

	\cadre{
	\begin{pseudo}
	\Struct{Point}
		\Decl x : réel
		\Decl y : réel
	\EndStruct
	\end{pseudo}
	}

% =====================================================
\section{Déclaration d’une variable de type structuré}
% =====================================================

	Une fois un type structuré défini, la
	déclaration de variables de ce type est identique à celle des variables
	simples. Par exemple~:

	\cadre{
	\begin{pseudo}
	\Decl anniversaire, jourJ : Date
	\Decl départ, arrivée, unMoment : Moment
	\Decl a, b, centreGravité : Point
	\end{pseudo}
	}

% ====================================================
\section{Utilisation des variables de type structuré}
% ====================================================

	En général, pour manipuler une variable
	structurée ou en modifier le contenu, il faut agir au niveau de ses
	champs en utilisant les opérations permises selon leur type. Pour
	accéder à l’un des champs d’une variable structurée, il faut mentionner
	le nom de ce champ ainsi que celui de la variable dont il fait partie.
	Nous utiliserons la notation «~pointée~»~:

	\cadre{
	\begin{pseudo}
	\Stmt nomVariable.nomChamp
	\end{pseudo}
	}

	Exemple d’instructions utilisant les variables
	déclarées au paragraphe précédent~:

	\cadre{
	\begin{pseudo}
	\Let anniversaire.jour \Gets 15
	\Let anniversaire.mois \Gets 10
	\Let anniversaire.année \Gets 2014
	\Let arrivée.heure \Gets départ.heure + 2
	\Let centreGravité.x \Gets (a.x + b.x) / 2
	\end{pseudo}
	}

	On peut cependant, dans certains cas, utiliser
	une variable structurée de manière globale (c’est-à-dire d’une façon
	qui agit simultanément sur chacun de ses champs). Le cas le plus
	courant est l’affectation interne entre deux variables structurées de
	même type, par exemple~:

	\cadre{
	\begin{pseudo}
	\Let arrivée \Gets départ
	\end{pseudo}
	}

	qui résume les trois instructions suivantes~:

	\cadre{
	\begin{pseudo}
	\Let arrivée.heure \Gets départ.heure
	\Let arrivée.minute \Gets départ.minute
	\Let arrivée.seconde \Gets départ.seconde
	\end{pseudo}
	}

	Une variable structurée peut aussi être le
	paramètre d’un module, et un module peut également renvoyer une
	«~valeur~» de type structuré. Par exemple, l’entête d’un module
	renvoyant le nombre de secondes écoulées entre une heure de départ et
	d’arrivée serait~:

	\cadre{
	\begin{pseudo}
	\ModuleSign{nbSecondesEcoulées}{ départ\In, arrivée\In : Moment}{entier}
	\end{pseudo}
	}

	On pourra aussi lire ou afficher une variable structurée\footnote{Bien que, dans certains
	langages, ces opérations devront être décomposées en une lecture ou
	écriture de chaque champ de la structure.}.

	\cadre{
	\begin{pseudo}
	\Read unMoment
	\Write unMoment
	\end{pseudo}
	}

	Par contre, il n’est pas autorisé d’utiliser
	les opérateurs de comparaison ({\textless}, {\textgreater}) pour
	comparer des variables structurées (même de même type), car une
	relation d’ordre n’accompagne pas toujours les structures utilisées. En
	effet, s’il est naturel de vouloir comparer des dates ou des moments,
	comment définir une relation d’ordre avec les points du plan ou avec
	des cartes d’identités~?

	Si le besoin de comparer des variables
	structurées se fait sentir, il faudra dans ce cas écrire des modules de
	comparaison adaptés aux structures utilisées.

	Par facilité d’écriture, on peut assigner tous les champs en une 
	fois via des «~\{\}~». Exemple~:

	\cadre{
	\begin{pseudo}
	\Let anniversaire \Gets \{1, 9, 1989\}
	\end{pseudo}
	}

% =============================
\section{Exemple d’algorithme}
% =============================

	Le module ci-dessous reçoit en paramètre deux dates ; la valeur renvoyée
	est –1 si la première date est antérieure à la deuxième, 0 si les deux
	dates sont identiques ou 1 si la première date est postérieure à la
	deuxième.

	\cadre{
	\begin{pseudo}
	\LComment Affiche 2 dates en paramètres et retourne la valeur
	\LComment {–1 si la première date est antérieure à la deuxième}
	\LComment 0 si les deux	dates sont identiques
	\LComment 1 si la première date est postérieure à la deuxième.
	\Module{comparerDates}{date1\In, date2\In : Date}{entier}
		\Decl résultat : entier
		\Let  résultat \Gets -1
		\RComment valeur choisie par défaut
		\If{date1.année ${\geq}$ date2.année}
			\If{date1.année $>$ date2.année}
				\Let  résultat \Gets 1
			\Else \RComment les années sont identiques
				\If{date1.mois ${\geq}$ date2.mois}
					\If{date1.mois $>$ date2.mois}
						\Let  résultat \Gets 1
					\Else \RComment les années et les mois sont identiques
						\If{date1.jour ${\geq}$ date2.jour}
							\If{date1.jour $>$ date2.jour}
								\Let  résultat \Gets 1
							\Else \RComment les années, les mois et les jours sont identiques
								\Let  résultat \Gets 0
							\EndIf
						\EndIf
					\EndIf
				\EndIf
			\EndIf
		\EndIf
		\Return résultat
	\EndModule
	\end{pseudo}
	}

% =====================================
\section{Exercices sur les structures}
% =====================================

\begin{Exercice}{Conversion moment-secondes}
	Écrire un module qui reçoit en paramètre un
	moment d’une journée et qui retourne le nombre de secondes écoulées
	depuis minuit jusqu’à ce moment.
\end{Exercice}

\begin{Exercice}{Conversion secondes-moment}
	Écrire un module qui reçoit en paramètre un
	nombre de secondes écoulées dans une journée à partir de minuit et qui
	retourne le moment correspondant de la journée.
\end{Exercice}

\begin{Exercice}{Temps écoulé entre 2 moments}
	Écrire un module qui reçoit en paramètres deux
	moments d’une journée et qui retourne le nombre de secondes séparant
	ces deux moments.
\end{Exercice}

\begin{Exercice}{Milieu de 2 points}
	Écrire un module recevant les coordonnées de
	deux points distincts du plan et qui retourne les coordonnées du point
	situé au milieu des deux.
\end{Exercice}

\begin{Exercice}{Distance entre 2 points}
	Écrire un module recevant les coordonnées de
	deux points distincts du plan et qui retourne
	la distance entre ces deux points.
\end{Exercice}

\begin{Exercice}{Un cercle}
	Définir un type \textbf{Cercle} pouvant décrire de façon
	commode un cercle quelconque dans un espace à deux dimensions. 
	
	Écrire ensuite
	
	\begin{enumerate}[label=\alph*)]
	\item {
		un module calculant la surface du cercle reçu en paramètre ;}
	\item {
		un module recevant 2 points en paramètre et retournant le cercle dont le
		diamètre est le segment reliant ces 2 points ;}
	\item {
		un module qui détermine si un point donné est dans un cercle ;}
	\item {
		un module qui indique si 2 cercles ont une intersection.
	}
	\end{enumerate}
\end{Exercice}


\begin{Exercice}{Un rectangle}
	\marginicon{java}
	Définir un type \textbf{Rectangle} pouvant décrire de façon
	commode un rectangle dans un espace à deux dimensions et dont les côtés
	sont parallèles aux axes des coordonnées. 
	
	Écrire ensuite

	\begin{enumerate}[label=\alph*)]
	\item {
		un module calculant le périmètre d’un rectangle reçu en paramètre ;}
	\item {
		un module calculant la surface d’un rectangle reçu en paramètre ;}
	\item {
		un module recevant en paramètre un rectangle R et les coordonnées
		d’un point P, et renvoyant 
		\textbf{vrai} si et seulement si le point P est à
		l’intérieur du rectangle R ;}
	\item {
		un module recevant en paramètre un rectangle R et les coordonnées
		d’un point P, et renvoyant 
		\textbf{vrai} si et seulement si le point P est sur le bord du
		rectangle R ;}
	\item {
		un module recevant en paramètre deux rectangles et renvoyant la valeur
		booléenne \textbf{vrai} si et seulement si ces deux rectangles ont une
		intersection.}
	\end{enumerate}
\end{Exercice}

\begin{Exercice}{Validation de date}
	Écrire un algorithme qui valide une date reçue en paramètre 
	sous forme d’une structure.
\end{Exercice}