Tip:
Highlight text to annotate it
X
%\documentclass[correction]{S2} \documentclass[12pt]{S2}
%\usepackage{french} %\documentclass[12pt]{article}
\usepackage[francais]{babel} \usepackage[latin1]{inputenc}
\newcommand{\aff}{\leftarrow} \renewcommand{\>}{\hspace*{4ex}}
\begin{document} \entete{TP}{5}
\sujet{Type produit}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \begin{exo}\\
Voici un exemple du type produit \'ecrit en langage C.
Un produit en langage C est introduit par le mot reserv\'e {\it struct} :
\begin{verbatim} #include
#include
struct TrainRER{ char nom[5]; // Le code de 4 lettres du train
("EXAL", "IFET", "ESON",...) int heure; // Heure de depart 8h10 = 810
char terminus[100]; // "Robinson", "Mitry",... };
int main(){ struct TrainRER unTrain;
printf("Entrez le nom du train (4 lettres max) : ");
gets(unTrain.nom); printf("Entrez le terminus : ");
gets(unTrain.terminus); printf("Entrez l'heure de depart : ");
scanf("%d", &unTrain.heure);
printf("Train %s part à %02dh%02d en direction de %s\n",
unTrain.nom, unTrain.heure/100, unTrain.heure%100, unTrain.terminus);
} \end{verbatim}
Modifier ce programme pour inclure dans le type {\it TrainRER} la longueur du train (en
nombre de voitures).
On utilise en g\'en\'eral des fonctions r\'eutilisables pour manipuler des types produits. Par exemple,
une fonction afficher :
\begin{verbatim} void afficher(struct TrainRER *t){
printf("Train %s part à %02dh%02d en direction de %s\n",
t->nom, t->heure/100, t->heure%100, t->terminus); }
\end{verbatim}
Ecrire de façon similaire une fonction pour saisir un train. Modifier la fonction main
pour utiliser ces fonctions.
\begin{solution} \begin{verbatim}
#include #include
struct TrainRER{ char nom[5];
int heure; char terminus[100];
int longueur; };
int main(){ struct TrainRER unTrain;
printf("Entrez le nom du train : "); gets(unTrain.nom);
printf("Entrez le terminus : "); gets(unTrain.terminus);
printf("Entrez l'heure de depart : "); scanf("%d", &unTrain.heure);
printf("Longueur en nombre de voitures : "); scanf("%d", &unTrain.longueur);
printf("Train %s part à %02dh%02d en direction de %s (avec %d voitures)\n",
unTrain.nom, unTrain.heure/100, unTrain.heure%100, unTrain.terminus, unTrain.longueur);
} \end{verbatim}
Puis
\begin{verbatim} #include
#include
struct TrainRER{ char nom[5];
int heure; char terminus[100];
int longueur; };
void afficher(struct TrainRER *t){ printf("Train %s part à %02dh%02d en direction
de %s (avec %d voitures)\n", t->nom, t->heure/100, t->heure%100, t->terminus,
t->longueur); }
void saisir(struct TrainRER *t){ printf("Entrez le nom du train : ");
gets(t->nom); printf("Entrez le terminus : ");
gets(t->terminus); printf("Entrez l'heure de depart : ");
scanf("%d", &t->heure); printf("Longueur en nombre de voitures : ");
scanf("%d", &t->longueur); }
int main(){ struct TrainRER unTrain;
saisir(&unTrain); afficher(&unTrain);
} \end{verbatim}
\end{solution} \end{exo}
\begin{exo}\\
On cherche à manipuler des droites dans le plan. Une droite du plan est d\'etermin\'ee
par une \'equation de la forme : $ax+by+c=0$. \\
Cr\'eer :
\begin{enumerate} \item le type produit \emph{droite} ;
\item une fonction permettant à l'utilisateur de saisir une variable de type droite ;
\item une fonction v\'erifiant si deux droites sont parall\`eles. On rappelle que deux droites
sont parall\`eles quand $a_1b_2=a_2b_1$ ; \end{enumerate}
\begin{solution} \begin{verbatim}
#include
typedef struct{ float a,b,c;
} droite;
droite saisir(){ droite x;
printf("Entrez les parametres d'une droite : \n");
scanf("%f%f%f",&x.a,&x.b,&x.c); return x;
}
int parallele(droite x,droite y){ return ((x.a*y.b - x.b*y.a) == 0);
}
int main(){ droite x,y;
printf("Ligne 1 :"); x = saisir();
printf("Ligne 2 :"); y = saisir();
if(parallele(x,y)){ printf("Elles sont paralleles!\n");
} else {
printf("Elles ne sont pas paralleles.\n"); }
return 0; }
\end{verbatim} \end{solution}
\end{exo}
\begin{exo} \\
On cherche à \'etudier la suite complexe qui intervient dans la d\'etermination de
l'ensemble de Mandelbrot. On consid\'erera qu'un nombre complexe $z$ s'\'ecrit sous la
forme $z=a+ib$, où a et b sont des r\'eels.
\begin{enumerate} \item Cr\'eer le type complexe.
\begin{solution} \begin{verbatim}
typedef struct{ float re,im;
}complexe; \end{verbatim}
\end{solution}
\item Cr\'eer une fonction de conversion de deux r\'eels $a$ et $b$ en un nombre complexe
$a+ib$. On ne demande pas dans cette fonction une saisie des nombres au clavier. Tester
votre fonction avec un programme principal qui affiche un nombre complexe saisie au clavier.
\begin{solution}
\begin{verbatim} complexe convert(float re,float im){
complexe res; res.re = re;
res.im = im; return res;
}
void affichage_nombre(complexe c){ if(c.im>0)
printf("nombre complex: %f + i * %f\n",c.re,c.im); else if(c.im2$
ou sinon renvoie $N$. Les points $3/4,1/2+i/2,-1-i/2$ appartiennent-ils à l'ensemble de Mandelbrot
?
\begin{solution} \begin{verbatim}
#define N 200
// Calcul un nombre n a partir duquel z_n sort de D(0,2) ou renvoie MAX
int mandel(complexe c,int max){ complexe z;
int t; t=0;
z = convert(c.re,c.im); while ((module(z)operande1);
printf(" %c ", a->operateur); affiche(a->operande2);
printf(")"); }
}
double calcul(struct arbre *a) { return 0.0;
}
int main() { double resultat;
struct arbre op1 = { 'v', 0, 0, 3.0 }; // Le nombre 3
struct arbre op2 = { 'v', 0, 0, 4.0 }; // Le nombre 4
struct arbre op3 = { '+', &op1, &op2, 0 }; // L'op\'eration op1 + op2 = 3 + 4
struct arbre op4 = { 'v', 0, 0, 5.0 }; // Le nombre 5
struct arbre op5 = { '*', &op3, &op4, 0 }; // L'op\'eration op3 * op4 = (3 + 4) * 5
printf("Formule : "); affiche(&op5);
printf("\n");
resultat = calcul(&op5); printf("Resultat = %g\n", resultat);
} \end{verbatim}
\begin{solution} \begin{verbatim}
double calcul(struct arbre *a) { switch(a->operateur){
case 'v': return a->val;
case '+': return calcul(a->operande1) + calcul(a->operande2);
case '-': return calcul(a->operande1) - calcul(a->operande2);
case '*': return calcul(a->operande1) * calcul(a->operande2);
case '/': return calcul(a->operande1) / calcul(a->operande2);
case '^': return pow(calcul(a->operande1), calcul(a->operande2));
default: printf("Op\'erateur inconnu : %c\n", a->operateur);
exit(1); }
} \end{verbatim}
\end{solution} \end{exo}
\end{document}