Université des Antilles et de la Guyane
Contrôle terminal Informatique (session 2) UEO12
Durée 1 heure 30
Juillet 2009 (polycopié, cours en ligne, notes de cours/TD et TP autorisés)
Proposition de correction – PEROUMALNAIK M. <mperouma@univ-ag.fr>
Question 1 (5 pts)
Ecrire une fonction nommée «mult» qui prend un entier en paramètre et qui renvoie un réel. Si le paramètre est pair, la fonction renvoie son double; si la paramètre est impaire la fonction renvoie la valeur de cet entier multiplié par 1.5. (on ne demande pas d'écrire de programme)
Proposition de correction commentée :
L'énoncé nous fournit l'ensemble des éléments nécessaires afin de rédiger l'entête de la fonction. En effet, il nous donne son nom (mult), son type de retour (float) et le type et le nombre de paramètres (int, un paramètre).
Nous pouvons donc déduire l'entête suivante : float mult(int variable)
Un nombre entier est pair si le reste de la division euclidienne de ce nombre par 2 vaut 0. En C, l'opérateur modulo (%) nous permet d'avoir le reste de la division euclidienne de deux nombres entiers.
Lorsque dans un énoncé il est mentionné « renvoie » en parlant d'une fonction, il s'agit généralement de la valeur à mettre à côté de return.
Forts de ces éléments, nous pouvons faire la proposition de correction suivante :
float mult(int variable)
{ //Si le nombre passé en paramètre est pair if(variable % 2 == 0)
{//Attention au type de renvoi de la fonction return 2.0 * variable;
}
//Sinon
else{ return 1.5 * variable;}
}
Question 2 ( 5 pts)
On veut travailler sur un tableau 2D defini par : int tab [6] [6]
Ecrire un programme qui demande à l'utilisateur de remplir ce tableau puis qui calcule et affiche la somme des éléments de la diagonale principale.
On remarquera que les élèments de la diagonale principale tab[i] [i] sont definis par un seul parametre i allant de 0 à 5
Proposition de correction commentée :
Première question à se poser lorsque l'on aborde un exercice de ce type : de combien de variables je vais avoir besoin ? Quels vont être leur type ?
Au cours du programme, nous allons traiter un tableau d'entiers à deux dimensions. Comme nous avons à le saisir, il va donc falloir réaliser une saisie pour chacune des cases composant chacune des lignes du tableau.
Nous allons donc répeter un traitement un nombre fini de fois (chaque case de la ligne) pour un nombre fini de lignes. Dès que l'on a un traitement qui se réalise un nombre fini de fois, le plus simple, c'est d'utiliser une boucle for.
Dans ce cas, nous avons à réaliser deux boucles for imbriquées, un grand classique du traitement de tableaux 2D.
Après la saisie, nous devons calculer puis afficher la somme des éléments de la diagonale principale. Dans l'énoncé, il est mentionné que les éléments de la diagonale ont le même indice de ligne et de colonne.
Il y a deux solutions possibles : soit calculer directement la somme pendant la saisie, soit réaliser une boucle après que le tableau soit saisi.
Dans cette proposition de correction, nous opterons pour le premier choix.
Au final, nous avons besoin de 4 variables : 1) le tableau d'entiers (int tab[6][6]) 2) la somme (int somme)
3) les compteurs des boucles (int i, j) Ci dessous, une proposition de correction :
#include<stdio.h>
main() {
int tab[6][6], i, j, somme;
//Initialisation de la somme somme = 0;
//Saisie du tableau //Pour chaque ligne for(i=0; i<6; i++) {
//Pour chaque élément de la ligne for(j=0; j<6; j++)
{
//Saisie de la case
printf(« Saisir la case [%d,%d] : »,i,j);
scanf(« %d », &(tab[i][j]));
//Si i et j sont égaux, on est sur la diagonale if(i==j)
{
//On ajoute la case à la somme somme = somme + tab[i][j];
} }
}
//Nous pouvons afficher la somme
printf(« La somme des éléments de la diagonale principale vaut : %d\n », somme);
}
Question 3 ( 5 pts)
Ecrire une fonction nommée «modifmax » qui ne renvoie rien, et qui a deux paramètres entier a et b (les paramètes a et b seront modifiés par la fonction). Si b est strictement supérieur à a, alors les valeurs des variables a et b doivent être permutés. Sinon la valeur de b est changé: b est mis à 0 (sa nouvelle valeur est 0).
Proposition de correction commentée :
Là encore, aucune difficulté. Il faut cependant garder à l'esprit que dès qu'une fonction DOIT MODIFIER des variables passées en paramètre, ces variables seront des POINTEURS.
En effet, les paramètres d'une fonction, tout comme toutes les variables déclarées au sein d'une fonction ont une portée locale. De ce fait, elles disparaissent après l'exécution de la fonction.
De ce fait, pour modifier une variable LOCALE, déclarée dans un contexte différent de celui de la fonction, nous sommes obligés de passer par l'adresse mémoire, donc par les pointeurs.
Concernant l'entête de la fonction, nous savons qu'elle ne renvoie rien. Son type de retour est donc (void). Elle prend en paramètre deux variables entières qu'elle doit MODIFIER. Nos deux paramètres seront donc des pointeurs sur des entiers.
Nous pouvons donc déduire l'entête suivante :
void modifmax(int* a, int* b)
Suivant le contenu de la variable pointée par b, nous allons soit permuter les contenus des variables pointées par a et b, soit mettre le contenu de la
Là encore aucune difficulté : il faut garder à l'esprit que l'on manipule des pointeurs : l'accès au contenu d'une variable pointée par un pointeur se réalise grâce à l'opérateur d'indirection, « * ».
Nous pouvons ainsi réaliser la proposition suivante : void modifmax(int*a, int*b)
{
//Pour la permutation int temp;
//Si b est plus grand que a if(*b > *a)
{
//Permutation temp = *b;
*b = *a;
*a = temp;
}
//Sinon else {
//Le contenu de la variable pointée par b => 0
*b = 0;
} }
Question 4 ( 5 pts) Soit la structure suivante:
struct Point3D {
float x;
float y;
float z;
};
Ecrire un programme qui utilise demande à l'utilisateur de rentrer des valeurs pour une variable nommé « Pt » de type Point3D puis qui modifie Pt en doublant les valeurs des champs x et y et en remplaçant la valeur du champ z par son opposé (-z). Le programme affichera les nouvelles valeurs des champs de Pt.
Proposition de correction commentée :
Des structures ... En plus, comme par hasard, l'exemple de cours, Point3D.
Les seules notions à maîtriser pour réaliser cet exercice sont : 1) La déclaration de variables structurées
2) L'accès aux champs d'une variable structurée.
Concernant l'accès, il se réalise en utilisant l'opérateur « . » de la façon suivante : nom_var.nom_champ
Le champ se comporte exactement comme une variable classique, comme nous allons le voir au cours de la proposition de correction suivante :
#include<stdio.h>
//Déclaration du type de variable structurée Point3D struct Point3D {
float x,y,z;
}
//Maintenant le programme main()
{
//Déclaration de Pt struct Point3D Pt;
//Saisie des champs
printf(« Saisir les coordonnées de Pt :\n »);
printf(« X : »);
//Saisie de l'attribut x de Pt scanf(« %f », &(Pt.x));
printf(« Y : »);
//Saisie de l'attribut y de Pt scanf(« %f », &(Pt.y));
printf(« Z : »);
//Saisie de l'attribut z de Pt scanf(« %f », &(Pt.z));
//Affichage de Pt
printf(« Avant : Pt(%0.2f, %0.2f %0.2f)\n »,Pt.x, Pt.y, Pt.z);
//Doubler la valeur des champs x et y Pt.x = 2.0*Pt.x;
Pt.y = 2.0*Pt.y;
//Inverser le champ z Pt.z = (1.0) * Pt.z;
//Nouvel affichage de Pt
printf(« Après : Pt(%0.2f, %0.2f %0.2f)\n »,Pt.x, Pt.y, Pt.z);
}
Voilà, cette proposition de correction est terminée.
En espérant que ça vous serve,
